mbindata2lda.cc

torch tracking code, it is a good code

const char *help = "\
progname: mbindata2lda.cc\n\
code2html: This program reads multiple bindata files and a LDA model, projects patterns into it.\n\
version: Torch3 vision2.0, 2003-2005\n\
(c) Sebastien Marcel ([e-mail])\n";

#include "string_utils.h"
#include "FileListCmdOption.h"
#include "str_utils.h"
#include "LDAMachine.h"
#include "CmdLine.h"

using namespace Torch;

int main(int argc, char *argv[])
{
	char *dir_name;
	char *model_filename;
	int n_input;
	int n_output;
	char *filename_out;
	real variance;
	bool verbose;
	int verbose_level;
	bool norm_d_mean;
	
	//
	FileListCmdOption filelist("file name", "the list files or one data file");
        filelist.isArgument(true);

	//
	CmdLine cmd;
	cmd.setBOption("write log", false);
	
	cmd.info(help);
	cmd.addText("\nArguments:");
  	cmd.addCmdOption(&filelist);
	cmd.addSCmdArg("model filename", &model_filename, "LDA model filename");
	cmd.addICmdArg("n_input", &n_input, "number of inputs");
	cmd.addText("\nOptions:");
	cmd.addSCmdOption("-dir", &dir_name, ".", "dir name");
	cmd.addSCmdOption("-o", &filename_out, "lda.bindata", "bindata output file");
	cmd.addRCmdOption("-variance", &variance, -1.0, "variance (-1 100\%)");
	cmd.addICmdOption("-n_output", &n_output, -1, "number of outputs (-1 auto)");
	cmd.addBCmdOption("-verbose", &verbose, false, "verbose");
	cmd.addICmdOption("-verbose_level", &verbose_level, 1, "level of verbose");
	cmd.addBCmdOption("-dnorm", &norm_d_mean, false, "norm d mean");
	cmd.read(argc, argv);

	if(verbose == false) verbose_level = 0;

	if(n_output > n_input) error("n_output > n_input");

	//
	LDAMachine *lda_machine = NULL;
	lda_machine = new LDAMachine(n_input, norm_d_mean);

	if(verbose_level >= 1)
		print("Loading LDA model: %s ...\n", model_filename);

	DiskXFile *file = NULL;
	file = new DiskXFile(model_filename, "r");
	lda_machine->loadXFile(file);
	delete file;
	   
	//
	lda_machine->setIOption("verbose_level", verbose_level);
	lda_machine->setROption("variance", variance);
	lda_machine->init();

	if(n_output != -1) lda_machine->n_outputs = n_output;
	else n_output = lda_machine->n_outputs;

	//
	float *realinput = NULL;
        Sequence *seq;

        realinput = new float [n_input];
        seq = new Sequence(&realinput, 1, n_input);	

	//
	int dimIn;
	int n_patterns;

	DiskXFile *pf = NULL;

	//
	for(int i = 0 ; i < filelist.n_files ; i++)
	{
		char *temp = strBaseName(filelist.file_names[i]);
		char *file_name = strRemoveSuffix(temp);

		if(verbose)
			print("Processing file %s\n", file_name);

		pf = new DiskXFile(filelist.file_names[i], "r");

		pf->read(&n_patterns, sizeof(int), 1);
		pf->read(&dimIn, sizeof(int), 1);

		if(verbose_level >= 1)
		{
			print("n_inputs : %d\n", dimIn);
			print("n_patterns : %d\n", n_patterns);  
		}

		if(n_input > dimIn)
		{
			error("Number of inputs specified (%d) bigger than into the file (%d)", n_input, dimIn);
	   
			delete pf;

			return 0;
		}


		//
		DiskXFile *pfOutput = NULL;
		char filename_out[250];

		sprintf(filename_out, "%s/%s.bindata", dir_name, file_name);
		
		pfOutput = new DiskXFile(filename_out, "w");

		//
		//
		if(verbose_level >= 1)
			print("Projection bindata file into PCA space (%d -> %d) ...\n", n_input, n_output);

		int P = n_patterns;

		pfOutput->write(&P, sizeof(int), 1);
		pfOutput->write(&n_output, sizeof(int), 1);

		for(int p = 0 ; p < P ; p++)
		{
	   		//
	  		for(int i = 0 ; i < n_input ; i++)
				pf->read(&realinput[i], sizeof(float), 1);   

			if(verbose_level >= 2) 
				print(" Seq =     [%2.3f %2.3f %2.3f ...]\n", realinput[0], realinput[1], realinput[2]);

			//
			lda_machine->forward(seq);
			
			if(verbose_level >= 2) 
				print(" Output =   [%2.3f %2.3f %2.3f ...]\n", lda_machine->outputs->frames[0][0], lda_machine->outputs->frames[0][1], lda_machine->outputs->frames[0][2]);

			float *machine_output = lda_machine->outputs->frames[0];

			//
			float data;
			for(int i = 0 ; i < n_output ; i++)
			{
		   		data = machine_output[i];

				pfOutput->write(&data, sizeof(float), 1);   
			}
		}

		//
		delete pf;
		delete pfOutput;
	}
	
	//
	delete seq;
	delete [] realinput;
	delete lda_machine;
	

	
  	return 0;
}