trainPCA.cc

 const char *help = "\
 progname: trainPCA.cc\n\
 code2html: This program computes PCA projection sub-space.\n\
 version: Torch3 vision2.0, 2003-2005\n\
 (c) Sebastien Marcel (marcel@idiap.ch)\n";
 
 #include "FileBinDataSet.h"
 #include "DiskBinDataSet.h"
 #include "PCATrainer.h"
 #include "MeanVarNorm.h"
 #include "HistoEqualSmoothImagePreProcessing.h"
 #include "FileListCmdOption.h"
 #include "CmdLine.h"
 
 using namespace Torch;
 			
 int main(int argc, char **argv)
 {
   	int n_inputs;
   	int offset_window;
   	int n_inputs_window;
   	char *model_file;
 	bool verbose;
 	int verbose_level;
 	bool normalize;
 	bool forward;
 	bool saveCovar;
 	bool use_disk;
 	bool image_normalize;
 	int width, height;
 
   	Allocator *allocator = new Allocator;
   	DiskXFile::setLittleEndianMode();
 
 
 	
   	//=================== The command-line ==========================
 	FileListCmdOption filelist("file name", "the list files or one data file");
         filelist.isArgument(true);
 
   	// Construct the command line
   	CmdLine cmd;
 	cmd.setBOption("write log", false);
 	
   	// Put the help line at the beginning
   	cmd.info(help);
 
   	cmd.addText("\nArguments:");
   	cmd.addCmdOption(&filelist);
   	cmd.addICmdArg("n_inputs", &n_inputs, "input dimension of the data", true);
   	cmd.addText("\nOptions:");
   	cmd.addICmdOption("-offset_window", &offset_window, 0, "offset window", true);
   	cmd.addICmdOption("-n_inputs_window", &n_inputs_window, -1, "input dimension of the window", true);
   	cmd.addBCmdOption("-saveCovar", &saveCovar, false, "save the covariance matrix", true);
   	cmd.addBCmdOption("-normalize", &normalize, false, "normalization", true);
   	cmd.addBCmdOption("-verbose", &verbose, false, "verbose", true);
   	cmd.addICmdOption("-verbose_level", &verbose_level, 0, "verbose level", true);
   	cmd.addBCmdOption("-forward", &forward, false, "project data into PCA sub-space", true);
   	cmd.addSCmdOption("-save", &model_file, "", "model file", true);
 	cmd.addBCmdOption("-use_disk", &use_disk, false, "use disk");
 	cmd.addBCmdOption("-imagenorm", &image_normalize, false, "considers the input pattern as an image and performs a photometric normalization");
 	cmd.addICmdOption("-width", &width, -1, "width");
 	cmd.addICmdOption("-height", &height, -1, "height");
 
   	// Read the command line
   	cmd.read(argc, argv);
 
 	if(n_inputs_window == -1) n_inputs_window = n_inputs;
 
 	if(image_normalize)
 	{
 		print("Perform photometric normalization ...\n");
 
 		print("The input pattern is an %dx%d image.\n", width, height);
 	}
 
 	//
 	if(verbose)
 	{
 		print(" + n_filenames = %d\n", filelist.n_files);
 		for(int i = 0 ; i < filelist.n_files ; i++)
 			print("   filename[%d] = %s\n", i, filelist.file_names[i]);
 	}
 
 
 	//
   	// The PCA Machine
 	PCAMachine *pca_machine = NULL;
 	pca_machine = new(allocator) PCAMachine(n_inputs_window);
 	pca_machine->setIOption("verbose_level", verbose_level);
 
 	//
 	// The PCA Trainer
 	Trainer *pca_trainer = NULL;
 
 	pca_trainer = new(allocator) PCATrainer(pca_machine);
 	pca_trainer->setBOption("saveCovar", saveCovar);
 	pca_trainer->setIOption("verbose_level", verbose_level);
 	
 
 	//
 	// Load all the data in the same dataset
 	DataSet *bindata = NULL;
 	
 	if(use_disk)
 	{
   		DiskBinDataSet *bindata_ = new(allocator) DiskBinDataSet(filelist.file_names, filelist.n_files, n_inputs, -1);
 	  	bindata_->info(false);
 
 		bindata = bindata_;
 	}
 	else
 	{
     		//FileBinDataSet *bindata = new(allocator) FileBinDataSet(filelist.file_names, filelist.n_files, 0.0, n_inputs);
 	    	//FileBinDataSet *bindata = new(allocator) FileBinDataSet(filelist.file_names, filelist.n_files, n_inputs, offset_window, n_inputs_window);
 	    	FileBinDataSet *bindata_ = new(allocator) FileBinDataSet(filelist.file_names, filelist.n_files, n_inputs, offset_window, n_inputs_window);
 		bindata_->info(false);	
 
 		bindata = bindata_;
 	}
 	
 	//
 	if(image_normalize)
 	{
 		print("Pre-processing image %dx%d ...\n", width, height);
 		PreProcessing *preprocess = new(allocator) HistoEqualSmoothImagePreProcessing(width, height);
 
 		bindata->preProcess(preprocess);
 	}
 	
 	//
 	MeanVarNorm *mv_norm = NULL;
 	if(normalize)
 	{
 	   	print("Normalization ...\n");
 
 		mv_norm = new(allocator) MeanVarNorm(bindata);
 		bindata->preProcess(mv_norm);
 	}
 
 
 	//
 	// Computes PCA
 	pca_trainer->train(bindata, NULL);
 
 
 	//
 	// Project data into PCA sub-space
 	real *realinput = NULL;
         Sequence *seq = NULL;
 
 	if(forward)
 	{
         	realinput = new real [n_inputs_window];
         	seq = new Sequence(&realinput, 1, n_inputs_window);
 	
 		//
 		pca_machine->setROption("variance", 0.95);
 		pca_machine->init();
 	
 		for(int i=0; i< bindata->n_examples; i++)
 		{
 			if(verbose) 
 	   			print("[%d]:\n", i);
 
 			//
 			bindata->setExample(i);
 		
 			if(verbose) 
 				print(" Input =   [%2.3f %2.3f %2.3f ...]\n", bindata->inputs->frames[0][0], bindata->inputs->frames[0][1], bindata->inputs->frames[0][2]);
 
 			//
 			bindata->inputs->copyTo(realinput);
 
 			if(verbose) 
 				print(" Seq =     [%2.3f %2.3f %2.3f ...]\n", realinput[0], realinput[1], realinput[2]);
 
 			//
 			pca_machine->forward(seq);
 			
 			if(verbose) 
 				print(" Output =   [%2.3f %2.3f %2.3f ...]\n", pca_machine->outputs->frames[0][0], pca_machine->outputs->frames[0][1], pca_machine->outputs->frames[0][2]);
 		}
 	}
 
 
 	//
 	// Save the model
 	if(strcmp(model_file, "") != 0)
 	{
 	   	if(normalize) 
 		{
 	   		print("Saving PCA model and its normalisation...\n");
 
 		   	pca_machine->save(model_file, mv_norm);
 		}
 		else
 		{
 	   		print("Saving PCA model ...\n");
 
 			DiskXFile *file = NULL;
 
 			file = new DiskXFile(model_file, "w");
 	
 			pca_machine->saveXFile(file);
 	
 			delete file;
 		}
 	}
 
 
 
 	//
 	// Free memory
 	if(forward)
 	{
 		delete [] realinput;
 		delete seq;
 	}
   	delete allocator;
 
   	return(0);
 }