trainlda.cc

torch tracking code, it is a good code

const char *help = "\
progname: trainLDA.cc\n\
code2html: This program computes a LDA projection sub-space.\n\
version: Torch3 vision2.0, 2003-2005\n\
(c) Sebastien Marcel ([e-mail])\n";

#include "FileBinDataSet.h"
#include "DiskBinDataSet.h"
#include "MMCTrainer.h"
#include "FisherLDATrainer.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 classprovided;
	bool within_is_identity;
	bool forward;
	bool use_disk;
	bool saveSbSw;
	bool mmc;
	
  	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("-verbose", &verbose, false, "verbose", true);
	cmd.addICmdOption("-verbose_level", &verbose_level, 0, "verbose level", true);
  	cmd.addBCmdOption("-forward", &forward, false, "project all data into lda", true);
  	cmd.addBCmdOption("-classprovided", &classprovided, false, "assign the targets", true);
  	cmd.addBCmdOption("-within_id", &within_is_identity, false, "the within scatter matrix is an identity matrix", true);
  	cmd.addSCmdOption("-save", &model_file, "", "model file", true);
	cmd.addBCmdOption("-use_disk", &use_disk, false, "use disk");
	cmd.addBCmdOption("-saveSbSw", &saveSbSw, false, "save Sb and Sw");
	cmd.addBCmdOption("-mmc", &mmc, false, "computes the Maximum Margin Criterion");

  	// Read the command line
  	cmd.read(argc, argv);

	if(n_inputs_window == -1) n_inputs_window = n_inputs;	

	//
	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]);
	}

	int n_classes = filelist.n_files;

  	//
	// The LDA Machine
	LDAMachine *lda_machine = NULL;

	lda_machine = new(allocator) LDAMachine(n_inputs_window);
	lda_machine->setIOption("verbose_level", verbose_level);

	//
	// The MMC/LDA Trainer
	Trainer *trainer = NULL;

	if(mmc)
	{
	   	print("Using MMC\n");

		trainer = new(allocator) MMCTrainer(n_classes, lda_machine);
	}
	else
	{
	   	print("Using Fisher LDA\n");

		trainer = new(allocator) FisherLDATrainer(n_classes, lda_machine);
		trainer->setBOption("within identity", within_is_identity);
	}
	trainer->setIOption("verbose_level", verbose_level);
	trainer->setBOption("class provided", classprovided);
	trainer->setBOption("save", saveSbSw);
	
	//
	// Load all the data in the same dataset
	real *targets = NULL;

	if(classprovided)
	{
		targets = (real *) allocator->alloc(sizeof(real) * filelist.n_files);
		for(int i = 0 ; i < filelist.n_files ; i++) targets[i] = (float) i;
	}

	DataSet *bindata = NULL;

	if(use_disk)
	{
	   	DiskBinDataSet *bindata_;
		
  		if(classprovided) bindata_ = new(allocator) DiskBinDataSet(filelist.file_names, filelist.n_files, n_inputs, targets, -1);
		else bindata_ = new(allocator) DiskBinDataSet(filelist.file_names, filelist.n_files, n_inputs, -1);
	  	bindata_->info(false);

		bindata = bindata_;
	}
	else
	{
	   	FileBinDataSet *bindata_;
		
		if(classprovided) bindata_ = new(allocator) FileBinDataSet(filelist.file_names, filelist.n_files, n_inputs, offset_window, n_inputs_window, targets);
	    	else bindata_ = new(allocator) FileBinDataSet(filelist.file_names, filelist.n_files, n_inputs, offset_window, n_inputs_window);
	  	bindata_->info(false);

		bindata = bindata_;
	}

	//
	// Computes LDA
	trainer->train(bindata, NULL);


	//
	// Projects data into LDA sub-space
	if(forward)
	{
		real *realinput = NULL;
        	Sequence *seq;

        	realinput = new real [n_inputs_window];
        	seq = new Sequence(&realinput, 1, n_inputs_window);
	
		//
		lda_machine->setROption("variance", 1.0);
		lda_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]);

			//
			lda_machine->forward(seq);
			
			if(verbose) 
				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]);
		}
	
		delete [] realinput;
		delete seq;
	}


	//
	// Save the model
	if(strcmp(model_file, "") != 0)
	{
	   	print("Saving LDA model ...\n");

		DiskXFile *file = NULL;

		file = new DiskXFile(model_file, "w");
	
		lda_machine->saveXFile(file);
	
		delete file;
	}
	
	//
  	delete allocator;

  	return(0);
}