app.cpp

一个遗传算法（GA）的实现。command line 的结构。输入输出格式请见命令行

/*----------------------------------------------------------------------------*/
/* app.c - application dependent routines, change these for different problem */
/*----------------------------------------------------------------------------*/

#include "app.h"

#include <math.h>
#include <string.h>
#include <stdlib.h>
#include "utility.h"
#include "gmm.h"
#include "..\lib\L_ui.h"

//#define ROOTDIR "d:\\speech\\myfiles"
#define K 20
#define GROUP 30 // frames
#define LOOPMAX 1000

/* this routine should contain any application-dependent computations */
/* that should be performed before each GA cycle. called by main()	  */
int application()
{
	return 0;
}


/* application dependent data input, called by init_data() */
/* ask your input questions here, and put output in global variables */
int app_data()
{
	if (numfiles == 0)
		printf(" Target Speaker :                    --> ");
	fscanf(infp,"%s\n",&target);
	return 0;
}


/* application dependent free() calls, called by freeall() */
void app_free()
{
	int ii;
	
	delete Target;
	delete World;
	
	for (ii=0;ii<nCSamples;ii++)
	{
		if (!bflag)
		{
			delete[] CTProbBuffer[ii];
			delete[] CWProbBuffer[ii];
		}
		delete[] Cparam[ii];
	}
	if (!bflag)
	{
		delete[] CTProbBuffer;
		delete[] CWProbBuffer;
	}
	delete[] Cparam;
	
	for (ii=0;ii<nISamples;ii++)
	{
		if (!bflag)
		{
			delete[] ITProbBuffer[ii];
			delete[] IWProbBuffer[ii];
		}
		delete[] Iparam[ii];
	}
	if (!bflag)
	{
		delete[] ITProbBuffer;
		delete[] IWProbBuffer;
	}
	delete[] Iparam;
	
	delete[] CScore;
	delete[] IScore;
	delete[] Ffa;
	delete[] Ffr;

}


/* application dependent initialization routine called by intialize() */
// Calculate all probilities and stored in a table
int app_init()
{
	char cfname[50],ifname[50];
	
	strcpy(cfname,rootdir);
	strcat(cfname,"\\hmm\\hmm.1\\");
	strcat(cfname,target);
	Target->LoadGMMSet(cfname);
	
	strcpy(cfname,rootdir);
	strcat(cfname,"\\hmm\\hmm.1\\world");
	World->LoadGMMSet(cfname);
	
	strcpy(cfname,rootdir);
	strcat(cfname,"\\scr\\");
	strcat(cfname,target);
	strcat(cfname,".GA.scr");
	strcpy(ifname,rootdir);
	//	strcat(ifname,"\\scr\\impostor.te.scr"); // Don't use the test data
	strcat(ifname,"\\scr\\World.GA.scr");
	app_loadparam(cfname,ifname);

	return 0;
}


/* Application-dependent initial report called by initialize() */
int app_initreport()
{
	fprintf(outfp,"\n Processing speaker %s ...\n",target);
	return 0;
}


/* application dependent malloc() calls, called by initmalloc() */
int app_malloc()
{
	Target = new CGMM;
	World = new CGMM;
	return 0;
}


/* Application-dependent report, called by report() */
int app_report()
{
	return 0;
}


/* Application-dependent statistics calculations called by statistics() */
int app_stats(individual *pop)
{
	return 0;
}


/* objective function used in Goldberg's book */
/* fitness function is f(x) = x**n, 
normalized to range between 0 and 1,
where x is the chromosome interpreted as an
integer, and n = 10 */
int objfunc(individual *critter,const char *fname)
{
	// load all claiment's mfcc file (in app_malloc and app_init())
	int ii,ij,ik,idx;
	int trigger[1024];
	
	float fWeight[256],fsum;
	int GrayCode[2][2] = { {0,1},{3,2} };

	float fcsumProb = 0;
	float fisumProb = 0;

	int CLoop = nCSamples/GROUP;
	int ILoop = nISamples/GROUP;

	CLoop = ILoop = LOOPMAX;
	
	if (!CTProbBuffer || !CWProbBuffer || !ITProbBuffer || !IWProbBuffer)
		app_fillbuff();

	// translate the trigger
	app_translate(critter->chrom,trigger);
	
	// translate the weight ( if nBitPerUnit != 1)
	for (fsum=0,ik=0,ii=0;ik<lchrom;ii++,ik+=nBitPerUnit)
	{
		fWeight[ii] = GrayCode[trigger[ik]][trigger[ik+1]];
		fsum += fWeight[ii];
	}
	// weight normalization
	for (ik=0;ik<lchrom/nBitPerUnit;ik++)
		fWeight[ik] = 1 + fWeight[ik]/fsum*nValues/10.; // (1.0~1.3)

	for (ii=0;ii<CLoop;ii++)
	{
		CScore[ii] = 0;
		idx = rand()%(nCSamples-GROUP) ;
		for (ij=idx;ij<idx+GROUP;ij++)
		{
			if (bflag)
			{
				if (nBitPerUnit!=1)
					SayBye("nBitPerUnit!=1");
				CScore[ii] += (float)Target->LVectorProb(Cparam[ij],trigger) 
					- (float)World->LVectorProb(Cparam[ij],trigger);
			}else{
//				for (ik=0;ik<nValues;ik++)
//				{
//					if (trigger[ik])
//						CScore[ii] += (float)CTProbBuffer[ij][ik] - (float)CWProbBuffer[ij][ik];
//				}
				for (ik=0;ik<nValues;ik++)
				{
					CScore[ii] += ((float)CTProbBuffer[ij][ik] 
						- (float)CWProbBuffer[ij][ik]) * fWeight[ik];
				}
			}
		}
	}
	for (ii=0;ii<ILoop;ii++)
	{
		IScore[ii] = 0;
		idx = rand()%(nISamples-GROUP) ;
		for (ij=idx;ij<idx+GROUP;ij++)
		{
			if (bflag)
			{
				IScore[ii] += (float)Target->LVectorProb(Iparam[ij],trigger) 
					- (float)World->LVectorProb(Iparam[ij],trigger);
			}else{
//				for (ik=0;ik<nValues;ik++)
//				{
//					if (trigger[ik])
//						IScore[ii] += (float)ITProbBuffer[ij][ik] - (float)IWProbBuffer[ij][ik];
//				}
				for (ik=0;ik<nValues;ik++)
				{
					IScore[ii] += ((float)ITProbBuffer[ij][ik]
						- (float)IWProbBuffer[ij][ik]) * fWeight[ik];
				}
			}
		}
	}

	// Calc the fitness value - EER
	fastsort(CScore,0,CLoop-1);
	fastsort(IScore,0,ILoop-1);

	if (fname)
	{
		char fn[100];
		strcpy(fn,fname);
		strcat(fn,"1");
		FILE *fp = fopen(fn,"w");
		for (ii=0;ii<CLoop;ii++)
			fprintf(fp,"a b/c %f\n",CScore[ii]);
		fclose(fp);
		strcpy(fn,fname);
		strcat(fn,"2");
		fp = fopen(fn,"w");
		for (ii=0;ii<ILoop;ii++)
			fprintf(fp,"a b/c %f\n",IScore[ii]);
		fclose(fp);
	}

	// Use EER as the fitness
//	critter->fitness = CalcFAFR(CScore,CLoop,IScore,ILoop);
//	critter->fitness = 1/(0.01+critter->fitness);
	
	// Use FOM Area as the fitness
	critter->fitness = CalcFOMArea(CScore,CLoop,IScore,ILoop,0.02);
	return 0;
}

//--------------------------------------------------------
// Load all mfcc of the target speaker and the impostors
// scfname: list of the target speaker test files
// sifname: list of the impostor speakers test files
int app_loadparam(char *scfname,char *sifname)
{
	int ii,ij,ik;
	FILE *fp;
	char parafname[300][100];
	float ***param;
	int *iframes;
	
	// Load target speaker's parameters
	
	if ((fp=fopen(scfname,"r"))==NULL)
	{ // success ?
		fprintf(outfp,"\n *** Error open %s, program exit!\n",scfname);
		exit(-1);
	}
	printf(" - Loading target speaker data (%s)...... ",target);
	iCFiles = 0;
	while (!feof(fp))
	{
		fscanf(fp,"%s",parafname[iCFiles]);
		iCFiles ++;
	}
	iCFiles--; // to avoid the tailed blank line
	fclose(fp);
	
	// load mfc file to param
	param = new float**[iCFiles]; // total files
	iframes = new int[iCFiles];
	nCSamples = 0;
	for (ii=0;ii<iCFiles;ii++)
	{
		nValues = app_loadmfc(parafname[ii],&param[ii],&iframes[ii]);
		nCSamples += iframes[ii];
	}
	//CScore = new float[nCSamples/GROUP];
	CScore = new float[LOOPMAX];
	
	// copy from param to Cparam
	Cparam = new float*[nCSamples];
	for (ii=0,ik=0;ii<iCFiles;ii++)
	{
		for (ij=0;ij<iframes[ii];ij++,ik++)
		{
			Cparam[ik] = new float[nValues];
			memcpy(Cparam[ik],param[ii][ij],sizeof(float)*nValues);
			delete[] param[ii][ij];
		}
		delete[] param[ii];
	}
	delete[] param;
	delete[] iframes;
	
	printf(" <Fle: %d> <Frame: %d> OK!\n",iCFiles,nCSamples);
	// Load impostor's parameters
	
	if ((fp=fopen(sifname,"r"))==NULL)
	{ // success ?
		fprintf(outfp,"\n *** Error open %s, program exit!\n",sifname);
		exit(-1);
	}
	printf(" - Loading all Impostor features ...... ");
	iIFiles = 0;
	while (!feof(fp))
	{
		fscanf(fp,"%s",parafname[iIFiles]);
		iIFiles ++;
	}
	iIFiles --; // to avoid tailed blank line
	fclose(fp);
	
	// load mfc file to param
	param = new float**[iIFiles]; // total files
	iframes = new int[iIFiles];
	nISamples = 0;
	for (ii=0;ii<iIFiles;ii++)
	{
		nValues = app_loadmfc(parafname[ii],&param[ii],&iframes[ii]);
		nISamples += iframes[ii];
	}
	//IScore = new float[nISamples/GROUP];
	IScore = new float[LOOPMAX];
	
	// copy from param to Cparam
	Iparam = new float*[nISamples];
	for (ii=0,ik=0;ii<iIFiles;ii++)
	{
		for (ij=0;ij<iframes[ii];ij++,ik++)
		{
			Iparam[ik] = new float[nValues];
			memcpy(Iparam[ik],param[ii][ij],sizeof(float)*nValues);
			delete[] param[ii][ij];
		}
		delete[] param[ii];
	}
	delete[] param;
	delete[] iframes;
	
//	Ffa = new float[nCSamples/GROUP+nISamples/GROUP];
//	Ffr = new float[nCSamples/GROUP+nISamples/GROUP];
	Ffa = new float[LOOPMAX+LOOPMAX];
	Ffr = new float[LOOPMAX+LOOPMAX];
	
	printf(" <Fle: %d> <Frame: %d> OK!\n",iIFiles,nISamples);
	if (nCSamples>0x7fff || nISamples>0x7fff)
		printf("\n ### Warning! Samples is larger than RAND_MAX <in objfunc()>.\n");
	return 0;
}

//----------------------------------------------------------------------------------
// Load one HTK mfc file.
// fname: file name
// datbuf: buffer to write
// isamples: frames in the file
// RETURN:
//	  dimension of frame vectors
int app_loadmfc(char *fname,float ***databuf,int *isamples)
{
	struct htk_header {
		long nSamples;
		long sampPeriod;
		short sampSize;
		short parmKind;
	}fheader;
	
	int ii,ij,idim;
	FILE *fp;
	//	FILE *fp1;
	
	if ((fp=fopen(fname,"rb"))==NULL)
	{
		fprintf(outfp,"\n *** Error open %s, program exit!\n",fname);
		exit(-1);
	}
	
	fread(&fheader,sizeof(fheader),1,fp);
	fheader.nSamples = app_flip_long(fheader.nSamples);
	*isamples = fheader.nSamples;
	fheader.sampPeriod = app_flip_long(fheader.sampPeriod);
	fheader.sampSize = app_flip_short(fheader.sampSize);
	fheader.parmKind = app_flip_short(fheader.parmKind);
	
	idim = fheader.sampSize / sizeof(float); // should equals lchrom
	if (idim != lchrom/nBitPerUnit)
	{
		fprintf(outfp," *** <idim(%d) != lchrom(%d) / %d> in app_loadmfc()\n",idim,lchrom,nBitPerUnit);
		fprintf(outfp,"     - %s\n",fname);
		exit(-1);
	}
	*databuf = new float*[*isamples];
	for (ii=0;ii<*isamples;ii++)
	{
		(*databuf)[ii] = new float[idim];
		ij = fread((*databuf)[ii],sizeof(float),idim,fp);
		for (ij=0;ij<idim;ij++)
			(*databuf)[ii][ij] = app_flip_float((*databuf)[ii][ij]);
	}
	fclose(fp);
	
	return idim;
}

long app_flip_long(long lin)
{
	long lout;
	_int8 *i8in,*i8out,ii;
	
	i8in = (_int8*)&lin;
	i8out = (_int8*)&lout;
	
	for (ii=0;ii<sizeof(long);ii++)
		i8out[ii] = i8in[sizeof(long)-1-ii];
	
	return lout;
}

float app_flip_float(float fin)
{
	float fout;
	_int8 *i8in,*i8out,ii;
	
	i8in = (_int8*)&fin;
	i8out = (_int8*)&fout;
	
	for (ii=0;ii<sizeof(float);ii++)
		i8out[ii] = i8in[sizeof(float)-1-ii];
	
	return fout;
}

short app_flip_short(short sin)
{
	short sout;
	_int8 *i8in,*i8out,ii;
	
	i8in = (_int8*)&sin;
	i8out = (_int8*)&sout;
	
	for (ii=0;ii<sizeof(short);ii++)
		i8out[ii] = i8in[sizeof(short)-1-ii];
	
	return sout;
}

void app_translate(unsigned *input,int *output)
{
	int i, j, k, stop;
	unsigned mask = 1, tmp;
	
	i = 0;
	for(k = 0; k < chromsize; k++)
	{
		tmp = input[k];
		if(k == (chromsize-1))
			stop = lchrom - (k*UINTSIZE);
		else
			stop = UINTSIZE;
		
		for(j = 0; j < stop; j++)
		{
			if(tmp&mask)
				output[i] = 1; //fprintf(outfp,"1");
			else
				output[i] = 0; //fprintf(outfp,"0");
			i ++;
			tmp = tmp>>1;
		}
	}
}

int app_fillbuff()
{
	int ii,ij;
	int iUnits = lchrom/nBitPerUnit; // dimension of the feature-vectors
	int nmixtures = Target->inst.iNumMixtures[0];
	
	CTProbBuffer = new double*[nCSamples];
	CWProbBuffer = new double*[nCSamples];
	for (ii=0;ii<nCSamples;ii++)
	{ // for each claiment file
		CTProbBuffer[ii] = new double[nValues];
		CWProbBuffer[ii] = new double[nValues];
		for (ij=0;ij<iUnits;ij++)
		{ // for each dimension
			Target->LScaleProb(Cparam[ii][ij],0,ij,CTProbBuffer[ii]+ij);
			World->LScaleProb(Cparam[ii][ij],0,ij,CWProbBuffer[ii]+ij);
		}
	}
	
	ITProbBuffer = new double*[nISamples];
	IWProbBuffer = new double*[nISamples];
	for (ii=0;ii<nISamples;ii++)
	{ // for each claiment file
		ITProbBuffer[ii] = new double[nValues];
		IWProbBuffer[ii] = new double[nValues];
		for (ij=0;ij<iUnits;ij++)
		{ // for each dimension
			Target->LScaleProb(Iparam[ii][ij],0,ij,ITProbBuffer[ii]+ij);
			World->LScaleProb(Iparam[ii][ij],0,ij,IWProbBuffer[ii]+ij);
		}
	}
	return 0;
}