trainpca.cc

torch tracking code, it is a good code

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 ([e-mail])\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);
}