#include <nnet-component.h>

Inheritance diagram for BlockAffineComponent:

Collaboration diagram for BlockAffineComponent:

[legend]

Public Member Functions
virtual int32	InputDim () const
	Get size of input vectors. More...

virtual int32	OutputDim () const
	Get size of output vectors. More...

virtual int32	GetParameterDim () const
	The following new virtual function returns the total dimension of the parameters in this class. More...

virtual void	Vectorize (VectorBase< BaseFloat > *params) const
	Turns the parameters into vector form. More...

virtual void	UnVectorize (const VectorBase< BaseFloat > &params)
	Converts the parameters from vector form. More...

void	Init (BaseFloat learning_rate, int32 input_dim, int32 output_dim, BaseFloat param_stddev, BaseFloat bias_stddev, int32 num_blocks)

virtual void	InitFromString (std::string args)
	Initialize, typically from a line of a config file. More...

	BlockAffineComponent ()

virtual std::string	Type () const

virtual bool	BackpropNeedsInput () const

virtual bool	BackpropNeedsOutput () const

virtual void	Propagate (const ChunkInfo &in_info, const ChunkInfo &out_info, const CuMatrixBase< BaseFloat > &in, CuMatrixBase< BaseFloat > *out) const
	Perform forward pass propagation Input->Output. More...

virtual void	Backprop (const ChunkInfo &in_info, const ChunkInfo &out_info, const CuMatrixBase< BaseFloat > &in_value, const CuMatrixBase< BaseFloat > &out_value, const CuMatrixBase< BaseFloat > &out_deriv, Component to_update, CuMatrix< BaseFloat > in_deriv) const
	Perform backward pass propagation of the derivative, and also either update the model (if to_update == this) or update another model or compute the model derivative (otherwise). More...

virtual void	SetZero (bool treat_as_gradient)
	Set parameters to zero, and if treat_as_gradient is true, we'll be treating this as a gradient so set the learning rate to 1 and make any other changes necessary (there's a variable we have to set for the MixtureProbComponent). More...

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

virtual void	Write (std::ostream &os, bool binary) const
	Write component to stream. More...

virtual BaseFloat	DotProduct (const UpdatableComponent &other) const
	Here, "other" is a component of the same specific type. More...

virtual Component *	Copy () const
	Copy component (deep copy). More...

virtual void	PerturbParams (BaseFloat stddev)
	We introduce a new virtual function that only applies to class UpdatableComponent. More...

virtual void	Scale (BaseFloat scale)
	This new virtual function scales the parameters by this amount. More...

virtual void	Add (BaseFloat alpha, const UpdatableComponent &other)
	This new virtual function adds the parameters of another updatable component, times some constant, to the current parameters. More...

Public Member Functions inherited from UpdatableComponent
	UpdatableComponent (const UpdatableComponent &other)

void	Init (BaseFloat learning_rate)

	UpdatableComponent (BaseFloat learning_rate)

	UpdatableComponent ()

virtual	~UpdatableComponent ()

void	SetLearningRate (BaseFloat lrate)
	Sets the learning rate of gradient descent. More...

BaseFloat	LearningRate () const
	Gets the learning rate of gradient descent. More...

virtual std::string	Info () const

Public Member Functions inherited from Component
	Component ()

virtual int32	Index () const
	Returns the index in the sequence of layers in the neural net; intended only to be used in debugging information. More...

virtual void	SetIndex (int32 index)

virtual std::vector< int32 >	Context () const
	Return a vector describing the temporal context this component requires for each frame of output, as a sorted list. More...

void	Propagate (const ChunkInfo &in_info, const ChunkInfo &out_info, const CuMatrixBase< BaseFloat > &in, CuMatrix< BaseFloat > *out) const
	A non-virtual propagate function that first resizes output if necessary. More...

virtual	~Component ()

Protected Member Functions
virtual void	Update (const CuMatrixBase< BaseFloat > &in_value, const CuMatrixBase< BaseFloat > &out_deriv)

virtual void	UpdateSimple (const CuMatrixBase< BaseFloat > &in_value, const CuMatrixBase< BaseFloat > &out_deriv)

Protected Attributes
CuMatrix< BaseFloat >	linear_params_

CuVector< BaseFloat >	bias_params_

int32	num_blocks_

Protected Attributes inherited from UpdatableComponent
BaseFloat	learning_rate_
	learning rate (0.0..0.01) More...

Private Member Functions
	KALDI_DISALLOW_COPY_AND_ASSIGN (BlockAffineComponent)

Additional Inherited Members
Static Public Member Functions inherited from Component
static Component *	ReadNew (std::istream &is, bool binary)
	Read component from stream. More...

static Component *	NewFromString (const std::string &initializer_line)
	Initialize the Component from one line that will contain first the type, e.g. More...

static Component *	NewComponentOfType (const std::string &type)
	Return a new Component of the given type e.g. More...

Detailed Description

Definition at line 1171 of file nnet-component.h.

Constructor & Destructor Documentation

◆ BlockAffineComponent()

BlockAffineComponent ( )

inline

Definition at line 1186 of file nnet-component.h.

1186 { } // use Init to really initialize.

Member Function Documentation

◆ Add()

void Add	(	BaseFloat	alpha,
		const UpdatableComponent &	other
	)

virtual

This new virtual function adds the parameters of another updatable component, times some constant, to the current parameters.

Implements UpdatableComponent.

Definition at line 1965 of file nnet-component.cc.

References AffineComponent::bias_params_, BlockAffineComponent::bias_params_, KALDI_ASSERT, AffineComponent::linear_params_, and BlockAffineComponent::linear_params_.

                                                                    {
   const BlockAffineComponent *other =
       dynamic_cast<const BlockAffineComponent*>(&other_in);
   KALDI_ASSERT(other != NULL);
   linear_params_.AddMat(alpha, other->linear_params_);
   bias_params_.AddVec(alpha, other->bias_params_);
 }

◆ Backprop()

void Backprop	(	const ChunkInfo &	in_info,
		const ChunkInfo &	out_info,
		const CuMatrixBase< BaseFloat > &	in_value,
		const CuMatrixBase< BaseFloat > &	out_value,
		const CuMatrixBase< BaseFloat > &	out_deriv,
		Component *	to_update,
		CuMatrix< BaseFloat > *	in_deriv
	)		const

virtual

Perform backward pass propagation of the derivative, and also either update the model (if to_update == this) or update another model or compute the model derivative (otherwise).

Note: in_value and out_value are the values of the input and output of the component, and these may be dummy variables if respectively BackpropNeedsInput() or BackpropNeedsOutput() return false for that component (not all components need these).

num_chunks lets us treat the input matrix as contiguous-in-time chunks of equal size; it only matters if splicing is involved.

Implements Component.

Definition at line 2035 of file nnet-component.cc.

References AffineComponent::InputDim(), KALDI_ASSERT, kaldi::kNoTrans, AffineComponent::linear_params_, CuMatrixBase< Real >::NumCols(), CuMatrixBase< Real >::NumRows(), CuMatrix< Real >::Resize(), and BlockAffineComponent::Update().

                                                                           {
 
   // This code mirrors the code in Propagate().
   int32 num_frames = in_value.NumRows();
   BlockAffineComponent *to_update = dynamic_cast<BlockAffineComponent*>(
       to_update_in);
   in_deriv->Resize(out_deriv.NumRows(), InputDim());
   int32 input_block_dim = linear_params_.NumCols(),
        output_block_dim = linear_params_.NumRows() / num_blocks_;
   KALDI_ASSERT(in_value.NumCols() == input_block_dim * num_blocks_);
   KALDI_ASSERT(out_deriv.NumCols() == output_block_dim * num_blocks_);
 
   for (int32 b = 0; b < num_blocks_; b++) {
     CuSubMatrix<BaseFloat> in_value_block(in_value, 0, num_frames,
                                         b * input_block_dim,
                                         input_block_dim),
         in_deriv_block(*in_deriv, 0, num_frames,
                        b * input_block_dim, input_block_dim),
         out_deriv_block(out_deriv, 0, num_frames,
                         b * output_block_dim, output_block_dim),
         param_block(linear_params_,
                     b * output_block_dim, output_block_dim,
                     0, input_block_dim);
 
     // Propagate the derivative back to the input.
     in_deriv_block.AddMatMat(1.0, out_deriv_block, kNoTrans,
                              param_block, kNoTrans, 0.0);
   }
   if (to_update != NULL)
     to_update->Update(in_value, out_deriv);
 }

◆ BackpropNeedsInput()

virtual bool BackpropNeedsInput ( ) const

inlinevirtual

Reimplemented from Component.

Definition at line 1188 of file nnet-component.h.

1188 { return true; }

◆ BackpropNeedsOutput()

virtual bool BackpropNeedsOutput ( ) const

inlinevirtual

Reimplemented from Component.

Definition at line 1189 of file nnet-component.h.

References kaldi::cu::Copy(), kaldi::nnet3::DotProduct(), kaldi::nnet3::PerturbParams(), and Component::Propagate().

1189 { return false; }

◆ Copy()

Component * Copy ( ) const

virtual

Copy component (deep copy).

Implements Component.

Reimplemented in BlockAffineComponentPreconditioned.

Definition at line 1951 of file nnet-component.cc.

References AffineComponent::bias_params_, BlockAffineComponent::bias_params_, UpdatableComponent::learning_rate_, AffineComponent::linear_params_, BlockAffineComponent::linear_params_, and BlockAffineComponent::num_blocks_.

                                             {
   BlockAffineComponent *ans = new BlockAffineComponent();
   ans->learning_rate_ = learning_rate_;
   ans->linear_params_ = linear_params_;
   ans->bias_params_ = bias_params_;
   ans->num_blocks_ = num_blocks_;
   return ans;
 }

◆ DotProduct()

BaseFloat DotProduct ( const UpdatableComponent & other ) const

virtual

Here, "other" is a component of the same specific type.

This function computes the dot product in parameters, and is computed while automatically adjusting learning rates; typically, one of the two will actually contain the gradient.

Implements UpdatableComponent.

Definition at line 1943 of file nnet-component.cc.

References AffineComponent::bias_params_, BlockAffineComponent::bias_params_, kaldi::kTrans, AffineComponent::linear_params_, BlockAffineComponent::linear_params_, kaldi::TraceMatMat(), and kaldi::VecVec().

                                               {
   const BlockAffineComponent *other =
       dynamic_cast<const BlockAffineComponent*>(&other_in);
   return TraceMatMat(linear_params_, other->linear_params_, kTrans)
       + VecVec(bias_params_, other->bias_params_);
 }

◆ GetParameterDim()

int32 GetParameterDim ( ) const

virtual

The following new virtual function returns the total dimension of the parameters in this class.

E.g. used for L-BFGS update

Reimplemented from UpdatableComponent.

Definition at line 2142 of file nnet-component.cc.

References AffineComponent::InputDim(), and AffineComponent::OutputDim().

                                                   {
   // Note: num_blocks_ should divide both InputDim() and OutputDim().
   return InputDim() * OutputDim() / num_blocks_;
 }

◆ Init()

void Init	(	BaseFloat	learning_rate,
		int32	input_dim,
		int32	output_dim,
		BaseFloat	param_stddev,
		BaseFloat	bias_stddev,
		int32	num_blocks
	)

Definition at line 2074 of file nnet-component.cc.

References AffineComponent::bias_params_, UpdatableComponent::Init(), KALDI_ASSERT, and AffineComponent::linear_params_.

Referenced by BlockAffineComponentPreconditioned::Init(), and kaldi::nnet2::UnitTestBlockAffineComponent().

                                                   {
   UpdatableComponent::Init(learning_rate);
   KALDI_ASSERT(output_dim > 0 && input_dim > 0 && param_stddev >= 0.0);
   KALDI_ASSERT(input_dim % num_blocks == 0 && output_dim % num_blocks == 0);
 
   linear_params_.Resize(output_dim, input_dim / num_blocks);
   bias_params_.Resize(output_dim);
 
   linear_params_.SetRandn(); // sets to random normally distributed noise.
   linear_params_.Scale(param_stddev);
   bias_params_.SetRandn();
   bias_params_.Scale(bias_stddev);
   num_blocks_ = num_blocks;
 }

◆ InitFromString()

void InitFromString ( std::string args )

virtual

Initialize, typically from a line of a config file.

The "args" will contain any parameters that need to be passed to the Component, e.g. dimensions.

Implements Component.

Reimplemented in BlockAffineComponentPreconditioned.

Definition at line 2093 of file nnet-component.cc.

References AffineComponentPreconditionedOnline::Init(), KALDI_ERR, UpdatableComponent::learning_rate_, and kaldi::nnet2::ParseFromString().

Referenced by kaldi::nnet2::UnitTestBlockAffineComponent().

                                                         {
   std::string orig_args(args);
   bool ok = true;
   BaseFloat learning_rate = learning_rate_;
   int32 input_dim = -1, output_dim = -1, num_blocks = 1;
   ParseFromString("learning-rate", &args, &learning_rate); // optional.
   ok = ok && ParseFromString("input-dim", &args, &input_dim);
   ok = ok && ParseFromString("output-dim", &args, &output_dim);
   ok = ok && ParseFromString("num-blocks", &args, &num_blocks);
   BaseFloat param_stddev = 1.0 / std::sqrt(input_dim),
       bias_stddev = 1.0;
   ParseFromString("param-stddev", &args, &param_stddev);
   ParseFromString("bias-stddev", &args, &bias_stddev);
   if (!args.empty())
     KALDI_ERR << "Could not process these elements in initializer: "
               << args;
   if (!ok)
     KALDI_ERR << "Bad initializer " << orig_args;
   Init(learning_rate, input_dim, output_dim,
        param_stddev, bias_stddev, num_blocks);
 }

◆ InputDim()

virtual int32 InputDim ( ) const

inlinevirtual

Get size of input vectors.

Implements Component.

Definition at line 1173 of file nnet-component.h.

1173 { return linear_params_.NumCols() * num_blocks_; }

kaldi::nnet2::BlockAffineComponent::num_blocks_

int32 num_blocks_

Definition: nnet-component.h:1232

kaldi::nnet2::BlockAffineComponent::linear_params_

CuMatrix< BaseFloat > linear_params_

Definition: nnet-component.h:1230

◆ KALDI_DISALLOW_COPY_AND_ASSIGN()

KALDI_DISALLOW_COPY_AND_ASSIGN ( BlockAffineComponent )

private

◆ OutputDim()

virtual int32 OutputDim ( ) const

inlinevirtual

Get size of output vectors.

Implements Component.

Definition at line 1174 of file nnet-component.h.

1174 { return linear_params_.NumRows(); }

kaldi::nnet2::BlockAffineComponent::linear_params_

CuMatrix< BaseFloat > linear_params_

Definition: nnet-component.h:1230

◆ PerturbParams()

void PerturbParams ( BaseFloat stddev )

virtual

We introduce a new virtual function that only applies to class UpdatableComponent.

This is used in testing.

Implements UpdatableComponent.

Definition at line 1933 of file nnet-component.cc.

References AffineComponent::bias_params_, AffineComponent::linear_params_, CuVectorBase< Real >::SetRandn(), and CuMatrixBase< Real >::SetRandn().

                                                          {
   CuMatrix<BaseFloat> temp_linear_params(linear_params_);
   temp_linear_params.SetRandn();
   linear_params_.AddMat(stddev, temp_linear_params);
 
   CuVector<BaseFloat> temp_bias_params(bias_params_);
   temp_bias_params.SetRandn();
   bias_params_.AddVec(stddev, temp_bias_params);
 }

◆ Propagate()

void Propagate	(	const ChunkInfo &	in_info,
		const ChunkInfo &	out_info,
		const CuMatrixBase< BaseFloat > &	in,
		CuMatrixBase< BaseFloat > *	out
	)		const

virtual

Perform forward pass propagation Input->Output.

Each row is one frame or training example. Interpreted as "num_chunks" equally sized chunks of frames; this only matters for layers that do things like context splicing. Typically this variable will either be 1 (when we're processing a single contiguous chunk of data) or will be the same as in.NumFrames(), but other values are possible if some layers do splicing.

Implements Component.

Definition at line 1974 of file nnet-component.cc.

References AffineComponent::bias_params_, ChunkInfo::CheckSize(), CuMatrixBase< Real >::CopyRowsFromVec(), KALDI_ASSERT, kaldi::kNoTrans, kaldi::kTrans, AffineComponent::linear_params_, ChunkInfo::NumChunks(), CuMatrixBase< Real >::NumCols(), and CuMatrixBase< Real >::NumRows().

                                                                           {
   in_info.CheckSize(in);
   out_info.CheckSize(*out);
   KALDI_ASSERT(in_info.NumChunks() == out_info.NumChunks());
 
   // The matrix has a block structure where each matrix has input dim
   // (#rows) equal to input_block_dim.  The blocks are stored in linear_params_
   // as [ M
   //      N
   //      O ] but we actually treat it as:
   // [ M 0 0
   //   0 N 0
   //   0 0 O ]
   int32 input_block_dim = linear_params_.NumCols(),
        output_block_dim = linear_params_.NumRows() / num_blocks_,
              num_frames = in.NumRows();
   KALDI_ASSERT(in.NumCols() == input_block_dim * num_blocks_);
   KALDI_ASSERT(out->NumCols() == output_block_dim * num_blocks_);
   KALDI_ASSERT(in.NumRows() == out->NumRows());
 
   out->CopyRowsFromVec(bias_params_); // copies bias_params_ to each row
   // of *out.
 
   for (int32 b = 0; b < num_blocks_; b++) {
     CuSubMatrix<BaseFloat> in_block(in, 0, num_frames,
                                   b * input_block_dim, input_block_dim),
         out_block(*out, 0, num_frames,
                   b * output_block_dim, output_block_dim),
         param_block(linear_params_,
                     b * output_block_dim, output_block_dim,
                     0, input_block_dim);
     out_block.AddMatMat(1.0, in_block, kNoTrans, param_block, kTrans, 1.0);
   }
 }

◆ Read()

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

virtual

Implements Component.

Reimplemented in BlockAffineComponentPreconditioned.

Definition at line 2116 of file nnet-component.cc.

References AffineComponent::bias_params_, kaldi::nnet2::ExpectOneOrTwoTokens(), kaldi::ExpectToken(), UpdatableComponent::learning_rate_, AffineComponent::linear_params_, and kaldi::ReadBasicType().

                                                            {
   ExpectOneOrTwoTokens(is, binary, "<BlockAffineComponent>", "<LearningRate>");
   ReadBasicType(is, binary, &learning_rate_);
   ExpectToken(is, binary, "<NumBlocks>");
   ReadBasicType(is, binary, &num_blocks_);
   ExpectToken(is, binary, "<LinearParams>");
   linear_params_.Read(is, binary);
   ExpectToken(is, binary, "<BiasParams>");
   bias_params_.Read(is, binary);
   ExpectToken(is, binary, "</BlockAffineComponent>");
 }

◆ Scale()

void Scale ( BaseFloat scale )

virtual

This new virtual function scales the parameters by this amount.

Implements UpdatableComponent.

Definition at line 1960 of file nnet-component.cc.

References AffineComponent::bias_params_, and AffineComponent::linear_params_.

                                                 {
   linear_params_.Scale(scale);
   bias_params_.Scale(scale);
 }

◆ SetZero()

void SetZero ( bool treat_as_gradient )

virtual

Set parameters to zero, and if treat_as_gradient is true, we'll be treating this as a gradient so set the learning rate to 1 and make any other changes necessary (there's a variable we have to set for the MixtureProbComponent).

Implements UpdatableComponent.

Reimplemented in BlockAffineComponentPreconditioned.

Definition at line 1925 of file nnet-component.cc.

References AffineComponent::bias_params_, AffineComponent::linear_params_, and UpdatableComponent::SetLearningRate().

Referenced by BlockAffineComponentPreconditioned::SetZero().

                                                          {
   if (treat_as_gradient) {
     SetLearningRate(1.0);
   }
   linear_params_.SetZero();
   bias_params_.SetZero();
 }

◆ Type()

virtual std::string Type ( ) const

inlinevirtual

Implements Component.

Reimplemented in BlockAffineComponentPreconditioned.

Definition at line 1187 of file nnet-component.h.

1187 { return "BlockAffineComponent"; }

◆ UnVectorize()

void UnVectorize ( const VectorBase< BaseFloat > & params )

virtual

Converts the parameters from vector form.

Reimplemented from UpdatableComponent.

Definition at line 2153 of file nnet-component.cc.

References AffineComponent::bias_params_, AffineComponent::linear_params_, and VectorBase< Real >::Range().

                                                                           {
   int32 l = linear_params_.NumRows() * linear_params_.NumCols(),
       b = bias_params_.Dim();
   linear_params_.CopyRowsFromVec(params.Range(0, l));
   bias_params_.CopyFromVec(params.Range(l, b));
 }

◆ Update()

virtual void Update	(	const CuMatrixBase< BaseFloat > &	in_value,
		const CuMatrixBase< BaseFloat > &	out_deriv
	)

inlineprotectedvirtual

Reimplemented in BlockAffineComponentPreconditioned.

Definition at line 1211 of file nnet-component.h.

Referenced by BlockAffineComponent::Backprop().

                                                 {
     UpdateSimple(in_value, out_deriv);
   }

◆ UpdateSimple()

void UpdateSimple	(	const CuMatrixBase< BaseFloat > &	in_value,
		const CuMatrixBase< BaseFloat > &	out_deriv
	)

protectedvirtual

Definition at line 2012 of file nnet-component.cc.

References CuMatrixBase< Real >::AddMatMat(), AffineComponent::bias_params_, kaldi::kNoTrans, kaldi::kTrans, UpdatableComponent::learning_rate_, AffineComponent::linear_params_, and CuMatrixBase< Real >::NumRows().

                                               {
   int32 input_block_dim = linear_params_.NumCols(),
       output_block_dim = linear_params_.NumRows() / num_blocks_,
       num_frames = in_value.NumRows();
 
   bias_params_.AddRowSumMat(learning_rate_, out_deriv, 1.0);
   for (int32 b = 0; b < num_blocks_; b++) {
     CuSubMatrix<BaseFloat> in_value_block(in_value, 0, num_frames,
                                         b * input_block_dim,
                                         input_block_dim),
         out_deriv_block(out_deriv, 0, num_frames,
                         b * output_block_dim, output_block_dim),
         param_block(linear_params_,
                     b * output_block_dim, output_block_dim,
                     0, input_block_dim);
     // Update the parameters.
     param_block.AddMatMat(learning_rate_, out_deriv_block, kTrans,
                           in_value_block, kNoTrans, 1.0);
   }
 }

◆ Vectorize()

void Vectorize ( VectorBase< BaseFloat > * params ) const

virtual

Turns the parameters into vector form.

We put the vector form on the CPU, because in the kinds of situations where we do this, we'll tend to use too much memory for the GPU.

Reimplemented from UpdatableComponent.

Definition at line 2147 of file nnet-component.cc.

References AffineComponent::bias_params_, AffineComponent::linear_params_, and VectorBase< Real >::Range().

                                                                         {
   int32 l = linear_params_.NumRows() * linear_params_.NumCols(),
       b = bias_params_.Dim();
   params->Range(0, l).CopyRowsFromMat(linear_params_);
   params->Range(l, b).CopyFromVec(bias_params_);
 }

◆ Write()

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

virtual

Write component to stream.

Implements Component.

Reimplemented in BlockAffineComponentPreconditioned.

Definition at line 2128 of file nnet-component.cc.

References AffineComponent::bias_params_, UpdatableComponent::learning_rate_, AffineComponent::linear_params_, kaldi::WriteBasicType(), and kaldi::WriteToken().

                                                                   {
   WriteToken(os, binary, "<BlockAffineComponent>");
   WriteToken(os, binary, "<LearningRate>");
   WriteBasicType(os, binary, learning_rate_);
   WriteToken(os, binary, "<NumBlocks>");
   WriteBasicType(os, binary, num_blocks_);
   WriteToken(os, binary, "<LinearParams>");
   linear_params_.Write(os, binary);
   WriteToken(os, binary, "<BiasParams>");
   bias_params_.Write(os, binary);
   WriteToken(os, binary, "</BlockAffineComponent>");
 }

Member Data Documentation

◆ bias_params_

CuVector<BaseFloat> bias_params_

protected

Definition at line 1231 of file nnet-component.h.

Referenced by BlockAffineComponent::Add(), BlockAffineComponent::Copy(), BlockAffineComponentPreconditioned::Copy(), and BlockAffineComponent::DotProduct().

◆ linear_params_

CuMatrix<BaseFloat> linear_params_

protected

Definition at line 1230 of file nnet-component.h.

Referenced by BlockAffineComponent::Add(), BlockAffineComponent::Copy(), BlockAffineComponentPreconditioned::Copy(), and BlockAffineComponent::DotProduct().

◆ num_blocks_

int32 num_blocks_

protected

Definition at line 1232 of file nnet-component.h.

Referenced by BlockAffineComponent::Copy(), and BlockAffineComponentPreconditioned::Copy().

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

nnet2/nnet-component.h
nnet2/nnet-component.cc

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ BlockAffineComponent()

Member Function Documentation

◆ Add()

◆ Backprop()

◆ BackpropNeedsInput()

◆ BackpropNeedsOutput()

◆ Copy()

◆ DotProduct()

◆ GetParameterDim()

◆ Init()

◆ InitFromString()

◆ InputDim()

◆ KALDI_DISALLOW_COPY_AND_ASSIGN()

◆ OutputDim()

◆ PerturbParams()

◆ Propagate()

◆ Read()

◆ Scale()

◆ SetZero()

◆ Type()

◆ UnVectorize()

◆ Update()

◆ UpdateSimple()

◆ Vectorize()

◆ Write()

Member Data Documentation

◆ bias_params_

◆ linear_params_

◆ num_blocks_