Example #1
0
/* symmeig -- computes eigenvalues of a dense symmetric matrix
	-- mat_a **must** be symmetric on entry
	-- eigenvalues stored in out
	-- mat_q contains orthogonal matrix of eigenvectors
	-- returns vector of eigenvalues
  -- je pense: if mat_q is NULL, eigenvectors won't be computed
*/
void mxSymEig(Mat * mat_a, Mat * mat_q, Vec * out)
{
  Mat *tmp = new Mat(mat_a->m, mat_a->n);
  tmp->copy(mat_a);

  Vec *b = new Vec(mat_a->m - 1);
  Vec *diag = new Vec(mat_a->m);
  Vec *beta = new Vec(mat_a->m);

  mxHFactor(tmp, diag, beta);
  if (mat_q)
    mxMakeHQ(tmp, diag, beta, mat_q);

  int i;
  for (i = 0; i < mat_a->m - 1; i++)
  {
    out->ptr[i] = tmp->ptr[i][i];
    b->ptr[i] = tmp->ptr[i][i + 1];
  }
  out->ptr[i] = tmp->ptr[i][i];

  mxTriEig(out, b, mat_q);

  delete beta;
  delete diag;
  delete b;
  delete tmp;
}
Example #2
0
  virtual MutableMat *copy(bool prefer_dense) const
  {
#if 0
    MutableMat *result = new MutableMat;
    Mat *m = mat.copy();
    result->mat.grab(m);
    return result;
#endif
    return clone();
  }
Example #3
0
bool SpeechRec::ProcessOffline(data_format inpf, data_format outpf, void *inpSig, int sigNBytes, Mat<float> *inpMat, Mat<float> *outMat)
{
	assert((int)inpf < (int)outpf);
	assert(outMat || outpf == dfStrings);
	assert(inpMat || inpf == dfWaveform);

	Mat<float> *paramMat = 0;
	Mat<float> *posteriorsMat = 0;

	// waveform -> parameters
	int nFrames;
	if(inpf == dfWaveform)
	{
		if(!ConvertWaveformFormat(waveFormat, inpSig, sigNBytes, &waveform, &waveformLen))
			return false;

		nFrames = (waveformLen > actualParams->GetVectorSize() ? (waveformLen - actualParams->GetVectorSize()) / actualParams->GetStep() + 1 : 1);
				
		actualParams->AddWaveform(waveform, waveformLen);
			
		if(outpf == dfParams)
		{
			paramMat = outMat;
		}
		else
		{
			paramMat = new Mat<float>; 
			if(!paramMat)
			{
				MERROR("Insufficient memory\n");
				return false;
			}
		}
		if(actualParams->GetNParams() != paramMat->columns() || nFrames != paramMat->rows())
		   paramMat->init(nFrames, actualParams->GetNParams());

		int fr = 0;
		while(actualParams->GetFeatures(params))
		{				
			FrameBasedNormalization(params, actualParams->GetNParams());
			paramMat->set(fr, fr, 0, actualParams->GetNParams() - 1, params);
			fr++;
		}

		if(outpf == dfParams)
			return true;
	}

	// sentence based normalization
	if(inpf == dfWaveform || inpf == dfParams)
	{
		if(inpf == dfParams)
			paramMat = inpMat;

                if(paramMat->columns() < actualParams->GetNParams())
                {
			MERROR("Invalid dimensionality of parameter vectors\n");
			return false;
                }
		else if(paramMat->columns() > actualParams->GetNParams())
		{
			Mat<float> *tmpMat = new Mat<float>;
			tmpMat->init(paramMat->rows(), actualParams->GetNParams());
			tmpMat->copy(*paramMat, 0, paramMat->rows() - 1, 0, actualParams->GetNParams() - 1, 
                                                   0, paramMat->rows() - 1, 0, actualParams->GetNParams() - 1);
			delete paramMat;
			paramMat = tmpMat;
			inpMat = paramMat;
		}

		SentenceBasedNormalization(paramMat);
	}

	// parameters -> posteriors
	if(outpf == dfPosteriors && !mTrapsEnabled)
        {
		MERROR("The 'traps' module have to be enabled for generating posteriors\n");
		return false;
        }

	if((inpf == dfWaveform || inpf == dfParams) && mTrapsEnabled)
	{
		if(inpf == dfParams)
			paramMat = inpMat;

		if(outpf == dfPosteriors)
		{
			posteriorsMat = outMat;
		}
		else
		{
			posteriorsMat = new Mat<float>;
			if(!posteriorsMat)
			{
				if(inpf != dfParams)
						delete paramMat;
				MERROR("Insufficient memory\n");
				return false;
			}
		}

		nFrames = paramMat->rows();

		if(TR.GetNumOuts() != posteriorsMat->columns() || nFrames != posteriorsMat->rows())
			posteriorsMat->init(nFrames, TR.GetNumOuts());

		// first part - initialization
		int i;
		int trapShift = TR.GetTrapShift();
		int nparams = actualParams->GetNParams();
		if(nFrames >= trapShift)
		{
			TR.CalcFeaturesBunched((float *)paramMat->getMem(), posteriors, trapShift, false);
		}
		else
		{
			sCopy(nFrames * paramMat->columns(), params, (float *)paramMat->getMem());
			for(i = nFrames; i < TR.GetTrapShift(); i++)
				paramMat->extr(nFrames - 1, nFrames - 1, 0, nparams - 1, params + i * nparams);
			TR.CalcFeaturesBunched(params, posteriors, trapShift, false);
		}

		// second part - main block
		if(nFrames > trapShift)
			TR.CalcFeaturesBunched((float *)paramMat->getMem() + trapShift * nparams, (float *)posteriorsMat->getMem(), nFrames - trapShift);

		// last part - termination
		int n = (nFrames > trapShift ? trapShift : nFrames);
		for(i = 0; i < n; i++)
			paramMat->extr(nFrames - 1, nFrames - 1, 0, nparams - 1, params + i * nparams);
		TR.CalcFeaturesBunched(params, (float *)posteriorsMat->getMem() + (nFrames - n) * posteriorsMat->columns(), n);

		// softening function: posteriors -> posteriors/log. posteriors
                int nPost = posteriorsMat->columns();
		for(i = 0; i < nFrames; i++)
		{
			posteriorsMat->extr(i, i, 0, nPost - 1, posteriors);
			int j;
			for(j = 0; j < nPost; j++)
				posteriors[j] = (*postSoftFunc)(posteriors[j], postSoftArg1, postSoftArg2, postSoftArg3);
			posteriorsMat->set(i, i, 0, nPost - 1, posteriors);
		}

		if(inpf != dfParams)
			delete paramMat;

		if(outpf == dfPosteriors)
			return true;
	}

	// posteriors -> strings
	if(inpf == dfWaveform || inpf == dfParams || inpf == dfPosteriors)
	{
		if(inpf == dfPosteriors || (inpf == dfParams && !mTrapsEnabled))
			posteriorsMat = inpMat;

		nFrames = posteriorsMat->rows();
                int nPost = posteriorsMat->columns(); // TR.GetNumOuts()

		// softening function: posteriors -> log. posteriors
		int i;
		for(i = 0; i < nFrames; i++)
		{
			posteriorsMat->extr(i, i, 0, nPost - 1, posteriors);
			int j;
			for(j = 0; j < nPost; j++)
				posteriors[j] = (*decSoftFunc)(posteriors[j], decSoftArg1, decSoftArg2, decSoftArg3);
			posteriorsMat->set(i, i, 0, nPost - 1, posteriors);
		}

		// log posteriors -> strings
		for(i = 0; i <  nFrames; i++)
		{
			posteriorsMat->extr(i, i, 0, nPost - 1, posteriors);
			DE->ProcessFrame(posteriors);
		}

		if(inpf != dfPosteriors)
			delete posteriorsMat;
	}

	return true;
}