NnetOnlineComputer Class Reference

#include <nnet-compute-online.h>

Collaboration diagram for NnetOnlineComputer:

Public Member Functions
	NnetOnlineComputer (const Nnet &nnet, bool pad_input)
void	Compute (const CuMatrixBase< BaseFloat > &input, CuMatrix< BaseFloat > *output)
void	Flush (CuMatrix< BaseFloat > *output)

Private Member Functions
void	Propagate ()
	KALDI_DISALLOW_COPY_AND_ASSIGN (NnetOnlineComputer)

Private Attributes
const Nnet &	nnet_
std::vector< CuMatrix< BaseFloat > >	data_
std::vector< ChunkInfo >	chunk_info_
std::vector< CuMatrix< BaseFloat > >	reusable_component_inputs_
CuMatrix< BaseFloat >	unprocessed_buffer_
CuVector< BaseFloat >	last_seen_input_frame_
bool	pad_input_
bool	is_first_chunk_
bool	finished_

Detailed Description

Definition at line 41 of file nnet-compute-online.h.

Constructor & Destructor Documentation

NnetOnlineComputer()

NnetOnlineComputer	(	const Nnet &	nnet,
		bool	pad_input
	)

Definition at line 28 of file nnet-compute-online.cc.

References NnetOnlineComputer::data_, NnetOnlineComputer::nnet_, Nnet::NumComponents(), and NnetOnlineComputer::reusable_component_inputs_.

    : nnet_(nnet), pad_input_(pad_input),
      is_first_chunk_(true), finished_(false) {
  data_.resize(nnet_.NumComponents() + 1);
  reusable_component_inputs_.resize(nnet_.NumComponents()+1);
}

Member Function Documentation

Compute()

void Compute	(	const CuMatrixBase< BaseFloat > &	input,
		CuMatrix< BaseFloat > *	output
	)

Definition at line 35 of file nnet-compute-online.cc.

References NnetOnlineComputer::chunk_info_, Nnet::ComputeChunkInfo(), CuMatrixBase< Real >::CopyFromMat(), NnetOnlineComputer::data_, NnetOnlineComputer::finished_, rnnlm::i, Nnet::InputDim(), NnetOnlineComputer::is_first_chunk_, KALDI_ASSERT, KALDI_ERR, NnetOnlineComputer::last_seen_input_frame_, Nnet::LeftContext(), NnetOnlineComputer::nnet_, CuMatrixBase< Real >::NumCols(), CuMatrixBase< Real >::NumRows(), NnetOnlineComputer::pad_input_, NnetOnlineComputer::Propagate(), CuMatrixBase< Real >::Range(), CuMatrix< Real >::Resize(), NnetOnlineComputer::reusable_component_inputs_, Nnet::RightContext(), CuMatrixBase< Real >::Row(), and NnetOnlineComputer::unprocessed_buffer_.

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

                                                              {
  KALDI_ASSERT(output != NULL);
  KALDI_ASSERT(!finished_);
  int32 dim = input.NumCols();

  // If input is empty, we also set output to zero size.
  if (input.NumRows() == 0) {
    output->Resize(0, 0);
    return;
  } else {
    // store the last frame as it might be needed for padding when Flush() is
    // called.
    if (last_seen_input_frame_.Dim() != input.NumCols())
      last_seen_input_frame_.Resize(input.NumCols());
    last_seen_input_frame_.CopyFromVec(input.Row(input.NumRows() - 1));
  }

  // Checking if feature dimension matches that required by the neural network.
  if (dim != nnet_.InputDim()) {
    KALDI_ERR << "Feature dimension is " << dim << ", but network expects "
        << nnet_.InputDim();
  }
  // num_effective_input_rows is the effective number of input rows we have, for
  // purposes of computing how much output we will get.  It is the number of
  // actual input rows plus the amount of context stored at intermediate layers
  // of the network (which if we have previously done the computation, will
  // equal nnet_.LeftContext() + nnet_.RightContext()).
  int32 num_effective_input_rows = 0;
  // Initialize the first element of data_, with input
  CuMatrix<BaseFloat> &input_data(data_[0]);
  if (is_first_chunk_)  {
    is_first_chunk_ = false;
    // assert that all the component-wise input buffers are empty
    for (int32 i = 0; i < reusable_component_inputs_.size(); i++)
      KALDI_ASSERT(reusable_component_inputs_[0].NumRows() == 0);
    // Pad at the start of the file if necessary.
    if ((pad_input_) && (nnet_.LeftContext() > 0))  {
        input_data.Resize(nnet_.LeftContext() + input.NumRows(), dim);
        input_data.Range(0, nnet_.LeftContext(), 0,
                    dim).CopyRowsFromVec(input.Row(0));
        input_data.Range(nnet_.LeftContext(), input.NumRows(),
                    0, dim).CopyFromMat(input);
    } else {
      input_data.Resize(input.NumRows(), input.NumCols());
      input_data.CopyFromMat(input);
    }
    num_effective_input_rows = input_data.NumRows();
  } else {
    int32 extra_input_rows = 0;
    // checking if we did forward pass for any chunks before.
    // if we did a forward pass, component input buffers would be non-empty
    // these buffers store information equivalent to having an nnet_input
    // buffer of (nnet_.LeftContext() + nnet_.RightContext())
    for (int32 i = 0; i < reusable_component_inputs_.size(); i++)  {
      if (reusable_component_inputs_[i].NumRows() > 0) {
        extra_input_rows = nnet_.LeftContext() + nnet_.RightContext();
        break;
      }
    }
    // add unprocessed input from the previous calls
    input_data.Resize(input.NumRows() + unprocessed_buffer_.NumRows(), dim);
    if (unprocessed_buffer_.NumRows() > 0)
      input_data.Range(0, unprocessed_buffer_.NumRows(),
                       0, dim).CopyFromMat(unprocessed_buffer_);
    input_data.Range(unprocessed_buffer_.NumRows(), input.NumRows(),
                     0, dim).CopyFromMat(input);
    unprocessed_buffer_.Resize(0, 0); // clearing the unprocessed buffer
    num_effective_input_rows = input_data.NumRows() + extra_input_rows;
  }
  if (num_effective_input_rows >=
      nnet_.LeftContext() + nnet_.RightContext() + 1) {
    // we have sufficient frames to compute at least one nnet output
    nnet_.ComputeChunkInfo(num_effective_input_rows, 1, &chunk_info_);
    Propagate();
    *output = data_.back();
  } else {
    // store the input in the unprocessed_buffer_
    unprocessed_buffer_ = input_data;
    // not enough input context so just return an empty array
    output->Resize(0, 0);
  }

}

Flush()

void Flush

(

CuMatrix< BaseFloat > *

output

)

Definition at line 120 of file nnet-compute-online.cc.

References NnetOnlineComputer::chunk_info_, Nnet::ComputeChunkInfo(), CuMatrixBase< Real >::CopyRowsFromVec(), NnetOnlineComputer::data_, NnetOnlineComputer::finished_, Nnet::InputDim(), NnetOnlineComputer::is_first_chunk_, KALDI_ASSERT, NnetOnlineComputer::last_seen_input_frame_, Nnet::LeftContext(), NnetOnlineComputer::nnet_, NnetOnlineComputer::pad_input_, NnetOnlineComputer::Propagate(), CuMatrix< Real >::Resize(), and Nnet::RightContext().

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

                                                          {
  KALDI_ASSERT(!finished_ && !is_first_chunk_);
  int32 num_frames_padding = (pad_input_ ? nnet_.RightContext() : 0);
  int32 num_stored_frames = nnet_.LeftContext() + nnet_.RightContext();
  int32 num_effective_input_rows =  num_stored_frames + num_frames_padding;
  // If the amount of output would be empty return at this point.
  if (num_effective_input_rows < nnet_.LeftContext() + nnet_.RightContext() + 1) {
    output->Resize(0, 0);
    finished_ = true;
    return;
  }

  int32 dim = nnet_.InputDim();
  CuMatrix<BaseFloat> &input_data(data_[0]);
  KALDI_ASSERT(num_frames_padding > 0);  // else we would have returned above.
  input_data.Resize(num_frames_padding, dim);
  input_data.CopyRowsFromVec(last_seen_input_frame_);

  // Note, we later modify this chunk-info, it isn't quite correct right now
  // because we add extra data at intermediate layers, and the actual number of
  // input rows doesn't equal num_effective_input_rows.
  nnet_.ComputeChunkInfo(num_effective_input_rows, 1,
                         &chunk_info_);
  Propagate();
  *output = data_.back();
  finished_ = true;
}

KALDI_DISALLOW_COPY_AND_ASSIGN()

KALDI_DISALLOW_COPY_AND_ASSIGN ( NnetOnlineComputer  )

private

Propagate()

void Propagate ( )

private

Definition at line 148 of file nnet-compute-online.cc.

References NnetOnlineComputer::chunk_info_, Component::Context(), NnetOnlineComputer::data_, Nnet::GetComponent(), Component::InputDim(), NnetOnlineComputer::nnet_, Nnet::NumComponents(), CuMatrixBase< Real >::NumRows(), Component::Propagate(), CuMatrixBase< Real >::Range(), CuMatrix< Real >::Resize(), NnetOnlineComputer::reusable_component_inputs_, and CuMatrixBase< Real >::RowRange().

Referenced by NnetOnlineComputer::Compute(), and NnetOnlineComputer::Flush().

                                   {
  // This method is like the normal nnet propagate, but we reuse the frames
  // computed from the previous chunk, at each component.

  for (int32 c = 0; c < nnet_.NumComponents(); c++) {
    // we assume that the chunks are always contiguous
    chunk_info_[c].MakeOffsetsContiguous();
    chunk_info_[c + 1].MakeOffsetsContiguous();

    const Component &component = nnet_.GetComponent(c);
    CuMatrix<BaseFloat> &input_data = data_[c], &output_data = data_[c + 1];
    CuMatrix<BaseFloat> input_data_temp;

    if (component.Context().size() > 1)  {
      int32 dim = component.InputDim();
      if (reusable_component_inputs_[c].NumRows() > 0) {
        // concatenate any frames computed by previous component
        // in the last call, to the input of the current component
        input_data_temp.Resize(reusable_component_inputs_[c].NumRows()
                               + input_data.NumRows(), dim);
        input_data_temp.Range(0, reusable_component_inputs_[c].NumRows(),
                       0, dim).CopyFromMat(reusable_component_inputs_[c]);
        input_data_temp.Range(reusable_component_inputs_[c].NumRows(),
                              input_data.NumRows(), 0, dim).CopyFromMat(
                                  input_data);
        input_data = input_data_temp;
      }
      // store any frames which can be reused in the next call
      reusable_component_inputs_[c].Resize(component.Context().back() -
                                component.Context().front(), dim);
      reusable_component_inputs_[c].CopyFromMat(
          input_data.RowRange(input_data.NumRows() -
                              reusable_component_inputs_[c].NumRows(),
                              reusable_component_inputs_[c].NumRows()));
    }

    // chunk_info objects provided assume that we added all the reusable
    // context at the input of the nnet. However we are reusing hidden
    // activations computed in the previous call.
    // Hence we manipulate the chunk_info objects to reflect the state of the
    // actual chunk, each component is computing, in the current Propagate.
    // As before we always assume the chunks are contiguous.

    // modifying the input chunk_info
    int32 chunk_size_assumed = chunk_info_[c].ChunkSize();
    int32 last_offset = chunk_info_[c].GetOffset(chunk_size_assumed - 1);
    int32 first_offset = last_offset - input_data.NumRows() + 1;
    ChunkInfo input_chunk_info(chunk_info_[c].NumCols(),
                               chunk_info_[c].NumChunks(),
                               first_offset,
                               last_offset);
    // modifying the output chunk_info
    chunk_size_assumed = chunk_info_[c + 1].ChunkSize();
    last_offset = chunk_info_[c + 1].GetOffset(chunk_size_assumed - 1);
    first_offset = last_offset - (input_data.NumRows() -
                                  (component.Context().back() -
                                   component.Context().front())) + 1;
    ChunkInfo output_chunk_info(chunk_info_[c + 1].NumCols(),
                                chunk_info_[c + 1].NumChunks(),
                                first_offset,
                                last_offset);
    component.Propagate(input_chunk_info, output_chunk_info,
                        input_data, &output_data);
  }
}

Member Data Documentation

chunk_info_

std::vector<ChunkInfo> chunk_info_

private

Definition at line 82 of file nnet-compute-online.h.

Referenced by NnetOnlineComputer::Compute(), NnetOnlineComputer::Flush(), and NnetOnlineComputer::Propagate().

data_

std::vector<CuMatrix<BaseFloat> > data_

private

Definition at line 80 of file nnet-compute-online.h.

Referenced by NnetOnlineComputer::Compute(), NnetOnlineComputer::Flush(), NnetOnlineComputer::NnetOnlineComputer(), and NnetOnlineComputer::Propagate().

finished_

bool finished_

private

Definition at line 101 of file nnet-compute-online.h.

Referenced by NnetOnlineComputer::Compute(), and NnetOnlineComputer::Flush().

is_first_chunk_

bool is_first_chunk_

private

Definition at line 99 of file nnet-compute-online.h.

Referenced by NnetOnlineComputer::Compute(), and NnetOnlineComputer::Flush().

last_seen_input_frame_

CuVector<BaseFloat> last_seen_input_frame_

private

Definition at line 93 of file nnet-compute-online.h.

Referenced by NnetOnlineComputer::Compute(), and NnetOnlineComputer::Flush().

nnet_

const Nnet& nnet_

private

Definition at line 76 of file nnet-compute-online.h.

Referenced by NnetOnlineComputer::Compute(), NnetOnlineComputer::Flush(), NnetOnlineComputer::NnetOnlineComputer(), and NnetOnlineComputer::Propagate().

pad_input_

bool pad_input_

private

Definition at line 97 of file nnet-compute-online.h.

Referenced by NnetOnlineComputer::Compute(), and NnetOnlineComputer::Flush().

reusable_component_inputs_

std::vector<CuMatrix<BaseFloat> > reusable_component_inputs_

private

Definition at line 85 of file nnet-compute-online.h.

Referenced by NnetOnlineComputer::Compute(), NnetOnlineComputer::NnetOnlineComputer(), and NnetOnlineComputer::Propagate().

unprocessed_buffer_

CuMatrix<BaseFloat> unprocessed_buffer_

private

Definition at line 89 of file nnet-compute-online.h.

Referenced by NnetOnlineComputer::Compute().

---

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

• nnet2/nnet-compute-online.h
• nnet2/nnet-compute-online.cc