trainhaarstump.cc

torch tracking code, it is a good code

const char *help = "\
progname: trainHaarStump.cc\n\
code2html: This program trains a linear combinaison of Haar-like stump classifiers.\n\
version: Torch3 vision2.0, 2003-2005\n\
(c) Sebastien Marcel ([e-mail]) and Yann Rodriguez ([e-mail])\n";

// Torch

// trainers
#include "TwoClassFormat.h"
#include "Boosting.h"

// measurers
#include "ClassMeasurer.h"

// command-lines
#include "FileListCmdOption.h"
#include "CmdLine.h"

/** Torch3vision
*/

// feature maker
#include "HaarFeatureMaker.h"

// Stump machines and trainers
#include "HaarStumpMachine.h"
#include "DiscreteStumpTrainer.h"
#include "HaarRealStumpMachine.h"
#include "RealStumpTrainer.h"
#include "ImageWeightedSumMachine.h"

// datasets
#include "FileBinDataSet.h"

// image processing
#include "ipIntegralImage.h"
#include "ipNormMeanStdvLight.h"

using namespace Torch;

int main(int argc, char **argv)
{
   	//
   	int width;
	int height;

	//
	int n_trainers = 10;
	
	//
	char *model_filename;

	//
	bool image_normalize;
	bool realstump;
	
	Allocator *allocator = new Allocator;

	FileListCmdOption filelist_class1("file name", "the list files or one data file of positive patterns");
	filelist_class1.isArgument(true);

	FileListCmdOption filelist_class0("file name", "the list files or one data file of negative patterns");
	filelist_class0.isArgument(true);

	//
	// Prepare the command-line
	CmdLine cmd;
	cmd.setBOption("write log", false);
	cmd.info(help);
	cmd.addText("\nArguments:");
	cmd.addCmdOption(&filelist_class1);
	cmd.addCmdOption(&filelist_class0);
	cmd.addICmdArg("width", &width, "width");
	cmd.addICmdArg("height", &height, "height");
	cmd.addText("\nOptions:");
	cmd.addBCmdOption("-real", &realstump, false, "uses real stump");
	cmd.addBCmdOption("-imagenorm", &image_normalize, false, "considers the input pattern as an image and performs a photometric normalization");
	cmd.addICmdOption("-n", &n_trainers, 10, "number of classifiers to train");
	cmd.addSCmdOption("-o", &model_filename, "model.wsm", "model filename");

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

	//
	print(" + class 1:\n");
        print("   n_filenames = %d\n", filelist_class1.n_files);
        for(int i = 0 ; i < filelist_class1.n_files ; i++)
                print("   filename[%d] = %s\n", i, filelist_class1.file_names[i]);

        print(" + class 0:\n");
        print("   n_filenames = %d\n", filelist_class0.n_files);
        for(int i = 0 ; i < filelist_class0.n_files ; i++)
                print("   filename[%d] = %s\n", i, filelist_class0.file_names[i]);

	int n_inputs = width * height;

	real the_target = 1.0;

	FileBinDataSet *data = NULL;
	data = new(allocator) FileBinDataSet(
	      			filelist_class1.file_names, filelist_class1.n_files, the_target,
        			filelist_class0.file_names, filelist_class0.n_files, -the_target, n_inputs);

        data->info(false);

	//
	print("Pre-processing ...\n");
	
	ipCore *i_machine = NULL;
	ipCore *inorm_machine = NULL;
	
	i_machine = new(allocator) ipIntegralImage(width, height, "gray");

	if(image_normalize)
		inorm_machine = new(allocator) ipNormMeanStdvLight(width, height, "float");
	
//#define TRACE
	
	for(int i=0; i< data->n_examples; i++)
	{
		data->setExample(i);
		real *input_ = data->inputs->frames[0];
#ifdef TRACE
		printf(" ORGI = [ ");
		for(int j = 0 ; j < width * height ; j++)
			printf("%g ", input_[j]);
		printf("]\n");
#endif

		Sequence *seqin = data->inputs;
		
		if(image_normalize)
		{
		   	// normalize the image
			inorm_machine->process(seqin);

			input_ = inorm_machine->seq_out->frames[0];			
		
#ifdef TRACE
			printf(" NORM = [ ");
			for(int j = 0 ; j < width * height ; j++)
				printf("%g ", input_[j]);
			printf("]\n");
#endif
			seqin = inorm_machine->seq_out;			
		}
			
		// computes its integral image
		i_machine->process(seqin);

		real *output_ = i_machine->seq_out->frames[0];
		
#ifdef TRACE
		printf(" INTI = [ ");
#endif
		for(int j = 0 ; j < width * height ; j++)
		{
			data->inputs->frames[0][j] = output_[j];
#ifdef TRACE
			printf("%g ", output_[j]);
#endif
		}
#ifdef TRACE
		printf("]\n");
#endif
	}
	
	//
	print("Haar feature maker ...\n");
	
	HaarFeatureMaker *haar = new(allocator) HaarFeatureMaker(5, width, height, 2, 19);
	
	print(" + number of features = %d\n", haar->n_features);
	

	//
	Trainer **trainers = (Trainer **)allocator->alloc(n_trainers*sizeof(Trainer *));
	for(int j = 0 ; j < n_trainers ; j++)
	{
	   	if(realstump)
		{
			HaarRealStumpMachine *s_machine = new(allocator) HaarRealStumpMachine(haar->n_features, haar->mask);
			trainers[j] = new(allocator) RealStumpTrainer(s_machine);
			trainers[j]->setBOption("verbose", false);
		}
		else
		{
			HaarStumpMachine *s_machine = new(allocator) HaarStumpMachine(haar->n_features, haar->mask);
			trainers[j] = new(allocator) DiscreteStumpTrainer(s_machine);
			trainers[j]->setBOption("verbose", true);
		}
	}
	 
	//
	ImageWeightedSumMachine *iwsm = new(allocator) ImageWeightedSumMachine(trainers, n_trainers, NULL);

	//
	TwoClassFormat *class_format = new(allocator) TwoClassFormat(data);

	Trainer *boost = NULL;
	
	boost = new(allocator) Boosting(iwsm, class_format);

	//
	MeasurerList measurers;
        ClassMeasurer *class_meas = new(allocator) ClassMeasurer(iwsm->outputs, data, class_format, cmd.getXFile("the_class_err"));
        measurers.addNode(class_meas);

	//
	boost->train(data, &measurers);

	//
	DiskXFile *model = new(allocator) DiskXFile(model_filename, "w");
	model->taggedWrite(&n_inputs, sizeof(int), 1, "N_INPUTS");
	model->taggedWrite(&n_trainers, sizeof(int), 1, "N_TRAINERS");
	iwsm->saveXFile(model);

	//
  	delete allocator;

  	return(0);
}