tesseract::WeightMatrix Class Reference

#include <weightmatrix.h>

Public Member Functions
	WeightMatrix ()
int	InitWeightsFloat (int no, int ni, bool use_adam, float weight_range, TRand *randomizer)
int	RemapOutputs (const std::vector< int > &code_map)
void	ConvertToInt ()
int	RoundInputs (int size) const
bool	is_int_mode () const
int	NumOutputs () const
const double *	GetWeights (int index) const
double	GetDW (int i, int j) const
void	InitBackward ()
bool	Serialize (bool training, TFile *fp) const
bool	DeSerialize (bool training, TFile *fp)
bool	DeSerializeOld (bool training, TFile *fp)
void	MatrixDotVector (const double *u, double *v) const
void	MatrixDotVector (const int8_t *u, double *v) const
void	MultiplyAccumulate (const double *v, double *inout)
void	VectorDotMatrix (const double *u, double *v) const
void	SumOuterTransposed (const TransposedArray &u, const TransposedArray &v, bool parallel)
void	Update (double learning_rate, double momentum, double adam_beta, int num_samples)
void	AddDeltas (const WeightMatrix &other)
void	CountAlternators (const WeightMatrix &other, double *same, double *changed) const
void	Debug2D (const char *msg)

Static Public Member Functions
static void	FloatToDouble (const GENERIC_2D_ARRAY< float > &wf, GENERIC_2D_ARRAY< double > *wd)

Detailed Description

Definition at line 65 of file weightmatrix.h.

Constructor & Destructor Documentation

WeightMatrix()

tesseract::WeightMatrix::WeightMatrix ( )

inline

Definition at line 67 of file weightmatrix.h.

: int_mode_(false), use_adam_(false) {}

Member Function Documentation

AddDeltas()

void tesseract::WeightMatrix::AddDeltas

(

const WeightMatrix &

other

)

Definition at line 337 of file weightmatrix.cpp.

                                                      {
  assert(dw_.dim1() == other.dw_.dim1());
  assert(dw_.dim2() == other.dw_.dim2());
  dw_ += other.dw_;
}

ConvertToInt()

void tesseract::WeightMatrix::ConvertToInt

(

)

Definition at line 125 of file weightmatrix.cpp.

                                {
  wi_.ResizeNoInit(wf_.dim1(), wf_.dim2());
  scales_.init_to_size(wi_.dim1(), 0.0);
  int dim2 = wi_.dim2();
  for (int t = 0; t < wi_.dim1(); ++t) {
    double* f_line = wf_[t];
    int8_t* i_line = wi_[t];
    double max_abs = 0.0;
    for (int f = 0; f < dim2; ++f) {
      double abs_val = fabs(f_line[f]);
      if (abs_val > max_abs) max_abs = abs_val;
    }
    double scale = max_abs / INT8_MAX;
    scales_[t] = scale;
    if (scale == 0.0) scale = 1.0;
    for (int f = 0; f < dim2; ++f) {
      i_line[f] = IntCastRounded(f_line[f] / scale);
    }
  }
  wf_.Resize(1, 1, 0.0);
  int_mode_ = true;
  if (IntSimdMatrix::intSimdMatrix) {
    IntSimdMatrix::intSimdMatrix->Init(wi_, shaped_w_);
  }
}

CountAlternators()

void tesseract::WeightMatrix::CountAlternators	(	const WeightMatrix &	other,
		double *	same,
		double *	changed
	)		const

Definition at line 346 of file weightmatrix.cpp.

                                                           {
  int num_outputs = updates_.dim1();
  int num_inputs = updates_.dim2();
  assert(num_outputs == other.updates_.dim1());
  assert(num_inputs == other.updates_.dim2());
  for (int i = 0; i < num_outputs; ++i) {
    const double* this_i = updates_[i];
    const double* other_i = other.updates_[i];
    for (int j = 0; j < num_inputs; ++j) {
      double product = this_i[j] * other_i[j];
      if (product < 0.0)
        *changed -= product;
      else
        *same += product;
    }
  }
}

Debug2D()

void tesseract::WeightMatrix::Debug2D

(

const char *

msg

)

Definition at line 377 of file weightmatrix.cpp.

                                          {
  STATS histogram(0, kHistogramBuckets);
  if (int_mode_) {
    for (int i = 0; i < wi_.dim1(); ++i) {
      for (int j = 0; j < wi_.dim2(); ++j) {
        HistogramWeight(wi_[i][j] * scales_[i], &histogram);
      }
    }
  } else {
    for (int i = 0; i < wf_.dim1(); ++i) {
      for (int j = 0; j < wf_.dim2(); ++j) {
        HistogramWeight(wf_[i][j], &histogram);
      }
    }
  }
  tprintf("%s\n", msg);
  histogram.print();
}

DeSerialize()

bool tesseract::WeightMatrix::DeSerialize	(	bool	training,
		TFile *	fp
	)

Definition at line 191 of file weightmatrix.cpp.

                                                       {
  uint8_t mode;
  if (!fp->DeSerialize(&mode)) return false;
  int_mode_ = (mode & kInt8Flag) != 0;
  use_adam_ = (mode & kAdamFlag) != 0;
  if ((mode & kDoubleFlag) == 0) return DeSerializeOld(training, fp);
  if (int_mode_) {
    if (!wi_.DeSerialize(fp)) return false;
    if (!scales_.DeSerialize(fp)) return false;
    if (IntSimdMatrix::intSimdMatrix) {
      IntSimdMatrix::intSimdMatrix->Init(wi_, shaped_w_);
    }
  } else {
    if (!wf_.DeSerialize(fp)) return false;
    if (training) {
      InitBackward();
      if (!updates_.DeSerialize(fp)) return false;
      if (use_adam_ && !dw_sq_sum_.DeSerialize(fp)) return false;
    }
  }
  return true;
}

DeSerializeOld()

bool tesseract::WeightMatrix::DeSerializeOld	(	bool	training,
		TFile *	fp
	)

Definition at line 216 of file weightmatrix.cpp.

                                                          {
  GENERIC_2D_ARRAY<float> float_array;
  if (int_mode_) {
    if (!wi_.DeSerialize(fp)) return false;
    GenericVector<float> old_scales;
    if (!old_scales.DeSerialize(fp)) return false;
    scales_.resize_no_init(old_scales.size());
    for (int i = 0; i < old_scales.size(); ++i) scales_[i] = old_scales[i];
  } else {
    if (!float_array.DeSerialize(fp)) return false;
    FloatToDouble(float_array, &wf_);
  }
  if (training) {
    InitBackward();
    if (!float_array.DeSerialize(fp)) return false;
    FloatToDouble(float_array, &updates_);
    // Errs was only used in int training, which is now dead.
    if (!float_array.DeSerialize(fp)) return false;
  }
  return true;
}

FloatToDouble()

void tesseract::WeightMatrix::FloatToDouble ( const GENERIC_2D_ARRAY< float > &  wf, GENERIC_2D_ARRAY< double > *  wd  )

static

Definition at line 399 of file weightmatrix.cpp.

                                                               {
  int dim1 = wf.dim1();
  int dim2 = wf.dim2();
  wd->ResizeNoInit(dim1, dim2);
  for (int i = 0; i < dim1; ++i) {
    const float* wfi = wf[i];
    double* wdi = (*wd)[i];
    for (int j = 0; j < dim2; ++j) wdi[j] = static_cast<double>(wfi[j]);
  }
}

GetDW()

double tesseract::WeightMatrix::GetDW ( int  i, int  j  ) const

inline

Definition at line 105 of file weightmatrix.h.

{ return dw_(i, j); }

GetWeights()

const double* tesseract::WeightMatrix::GetWeights ( int  index ) const

inline

Definition at line 103 of file weightmatrix.h.

{ return wf_[index]; }

InitBackward()

void tesseract::WeightMatrix::InitBackward

(

)

Definition at line 153 of file weightmatrix.cpp.

                                {
  int no = int_mode_ ? wi_.dim1() : wf_.dim1();
  int ni = int_mode_ ? wi_.dim2() : wf_.dim2();
  dw_.Resize(no, ni, 0.0);
  updates_.Resize(no, ni, 0.0);
  wf_t_.Transpose(wf_);
  if (use_adam_) dw_sq_sum_.Resize(no, ni, 0.0);
}

InitWeightsFloat()

int tesseract::WeightMatrix::InitWeightsFloat	(	int	no,
		int	ni,
		bool	use_adam,
		float	weight_range,
		TRand *	randomizer
	)

Definition at line 76 of file weightmatrix.cpp.

                                                                          {
  int_mode_ = false;
  wf_.Resize(no, ni, 0.0);
  if (randomizer != nullptr) {
    for (int i = 0; i < no; ++i) {
      for (int j = 0; j < ni; ++j) {
        wf_[i][j] = randomizer->SignedRand(weight_range);
      }
    }
  }
  use_adam_ = use_adam;
  InitBackward();
  return ni * no;
}

is_int_mode()

bool tesseract::WeightMatrix::is_int_mode ( ) const

inline

Definition at line 98 of file weightmatrix.h.

                           {
    return int_mode_;
  }

MatrixDotVector() [1/2]

void tesseract::WeightMatrix::MatrixDotVector	(	const double *	u,
		double *	v
	)		const

Definition at line 243 of file weightmatrix.cpp.

                                                                   {
  assert(!int_mode_);
  MatrixDotVectorInternal(wf_, true, false, u, v);
}

MatrixDotVector() [2/2]

void tesseract::WeightMatrix::MatrixDotVector	(	const int8_t *	u,
		double *	v
	)		const

Definition at line 248 of file weightmatrix.cpp.

                                                                   {
  assert(int_mode_);
  if (IntSimdMatrix::intSimdMatrix) {
    IntSimdMatrix::intSimdMatrix->matrixDotVectorFunction(
      wi_.dim1(), wi_.dim2(), &shaped_w_[0], &scales_[0], u, v);
  } else {
    IntSimdMatrix::MatrixDotVector(wi_, scales_, u, v);
  }
}

MultiplyAccumulate()

void tesseract::WeightMatrix::MultiplyAccumulate	(	const double *	v,
		double *	inout
	)

Definition at line 260 of file weightmatrix.cpp.

                                                                    {
  assert(!int_mode_);
  assert(wf_.dim1() == 1);
  int n = wf_.dim2();
  const double* u = wf_[0];
  for (int i = 0; i < n; ++i) {
    inout[i] += u[i] * v[i];
  }
}

NumOutputs()

int tesseract::WeightMatrix::NumOutputs ( ) const

inline

Definition at line 101 of file weightmatrix.h.

{ return int_mode_ ? wi_.dim1() : wf_.dim1(); }

RemapOutputs()

int tesseract::WeightMatrix::RemapOutputs

(

const std::vector< int > &

code_map

)

Definition at line 97 of file weightmatrix.cpp.

                                                             {
  GENERIC_2D_ARRAY<double> old_wf(wf_);
  int old_no = wf_.dim1();
  int new_no = code_map.size();
  int ni = wf_.dim2();
  std::vector<double> means(ni, 0.0);
  for (int c = 0; c < old_no; ++c) {
    const double* weights = wf_[c];
    for (int i = 0; i < ni; ++i) means[i] += weights[i];
  }
  for (double& mean : means) mean /= old_no;
  wf_.ResizeNoInit(new_no, ni);
  InitBackward();
  for (int dest = 0; dest < new_no; ++dest) {
    int src = code_map[dest];
    const double* src_data = src >= 0 ? old_wf[src] : means.data();
    memcpy(wf_[dest], src_data, ni * sizeof(*src_data));
  }
  return ni * new_no;
}

RoundInputs()

int tesseract::WeightMatrix::RoundInputs ( int  size ) const

inline

Definition at line 92 of file weightmatrix.h.

                                  {
    if (!int_mode_ || !IntSimdMatrix::intSimdMatrix) return size;
    return IntSimdMatrix::intSimdMatrix->RoundInputs(size);
  }

Serialize()

bool tesseract::WeightMatrix::Serialize	(	bool	training,
		TFile *	fp
	)		const

Definition at line 172 of file weightmatrix.cpp.

                                                           {
  // For backward compatibility, add kDoubleFlag to mode to indicate the doubles
  // format, without errs, so we can detect and read old format weight matrices.
  uint8_t mode =
      (int_mode_ ? kInt8Flag : 0) | (use_adam_ ? kAdamFlag : 0) | kDoubleFlag;
  if (!fp->Serialize(&mode)) return false;
  if (int_mode_) {
    if (!wi_.Serialize(fp)) return false;
    if (!scales_.Serialize(fp)) return false;
  } else {
    if (!wf_.Serialize(fp)) return false;
    if (training && !updates_.Serialize(fp)) return false;
    if (training && use_adam_ && !dw_sq_sum_.Serialize(fp)) return false;
  }
  return true;
}

SumOuterTransposed()

void tesseract::WeightMatrix::SumOuterTransposed	(	const TransposedArray &	u,
		const TransposedArray &	v,
		bool	parallel
	)

Definition at line 284 of file weightmatrix.cpp.

                                                        {
  assert(!int_mode_);
  int num_outputs = dw_.dim1();
  assert(u.dim1() == num_outputs);
  assert(u.dim2() == v.dim2());
  int num_inputs = dw_.dim2() - 1;
  int num_samples = u.dim2();
  // v is missing the last element in dim1.
  assert(v.dim1() == num_inputs);
#ifdef _OPENMP
#pragma omp parallel for num_threads(4) if (in_parallel)
#endif
  for (int i = 0; i < num_outputs; ++i) {
    double* dwi = dw_[i];
    const double* ui = u[i];
    for (int j = 0; j < num_inputs; ++j) {
      dwi[j] = DotProduct(ui, v[j], num_samples);
    }
    // The last element of v is missing, presumed 1.0f.
    double total = 0.0;
    for (int k = 0; k < num_samples; ++k) total += ui[k];
    dwi[num_inputs] = total;
  }
}

Update()

void tesseract::WeightMatrix::Update	(	double	learning_rate,
		double	momentum,
		double	adam_beta,
		int	num_samples
	)

Definition at line 314 of file weightmatrix.cpp.

                                                             {
  assert(!int_mode_);
  if (use_adam_ && num_samples > 0 && num_samples < kAdamCorrectionIterations) {
    learning_rate *= sqrt(1.0 - pow(adam_beta, num_samples));
    learning_rate /= 1.0 - pow(momentum, num_samples);
  }
  if (use_adam_ && num_samples > 0 && momentum > 0.0) {
    dw_sq_sum_.SumSquares(dw_, adam_beta);
    dw_ *= learning_rate * (1.0 - momentum);
    updates_ *= momentum;
    updates_ += dw_;
    wf_.AdamUpdate(updates_, dw_sq_sum_, learning_rate * kAdamEpsilon);
  } else {
    dw_ *= learning_rate;
    updates_ += dw_;
    if (momentum > 0.0) wf_ += updates_;
    if (momentum >= 0.0) updates_ *= momentum;
  }
  wf_t_.Transpose(wf_);
}

VectorDotMatrix()

void tesseract::WeightMatrix::VectorDotMatrix	(	const double *	u,
		double *	v
	)		const

Definition at line 274 of file weightmatrix.cpp.

                                                                   {
  assert(!int_mode_);
  MatrixDotVectorInternal(wf_t_, false, true, u, v);
}

---

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

• /tesseract/src/lstm/weightmatrix.h
• /tesseract/src/lstm/weightmatrix.cpp