#include <cstdlib>
#include <iostream>
#include <string>
#include <math.h>
#include "utils.h"
#include <float.h>
#include "onboostnn.h"

//using namespace std;
/* Constructor function. This sets the training example file and number
of base models. It also sets to NULL other variables to be used later. */
onboostnn::onboostnn(datafile* examples_to_train, long new_num_base_models,
				int new_num_epochs, int new_num_hidden, float newlearningrate,
				float newmomentumterm)
{
	if (new_num_epochs > 0)
	{
		num_epochs = new_num_epochs;
	}
	else
	{
		num_epochs = 100;
	}
	
	if (new_num_hidden > 0)
	{
		num_hidden = new_num_hidden;
	}

	if ((examples_to_train != NULL) && (new_num_base_models > 0))
	{
		setup(examples_to_train, new_num_base_models, new_num_epochs,
			new_num_hidden, newlearningrate, newmomentumterm);
	}
	else
	{
		training_examples = NULL;
		basemodels = NULL;
		lambda_correct = NULL;
		lambda_wrong = NULL;
		epsilons = NULL;
		betas = NULL;
		init_num_base_models = num_base_models = 0;
		classifications = NULL;
		votes = NULL;
	}
}


/* Destructor function. */
onboostnn::~onboostnn()
{
	delete [] basemodels;
	basemodels = NULL;
	delete [] lambda_correct;
	lambda_correct = NULL;
	delete [] lambda_wrong;
	lambda_wrong = NULL;
	delete [] epsilons;
	epsilons = NULL;
	delete [] betas;
	betas = NULL;
	delete [] classifications;
	classifications = NULL;
	delete [] votes;
	votes = NULL;
}


/* set_training_example_file:
Input: datafile containing the training examples.
Output: None.
Sets the training example file data structure to point to examples_to_train.
*/
void onboostnn::set_training_example_file(datafile* examples_to_train)
{
	training_examples = examples_to_train;
	
	if (votes != NULL)
	{
		delete [] votes;
	}
	votes = new double[training_examples->NumClasses()];
}


/* setup:
Inputs: datafile data structure, number of base models to be trained.
Output: none
This function sets the training example datafile data structure to point to
examples_to_train and sets the number of base models to be trained to 
new_num_base_models. 
*/
void onboostnn::setup(datafile* examples_to_train, long new_num_base_models,
			int new_num_epochs, int new_num_hidden,
			float newlearningrate, float newmomentumterm)
{
	training_examples = examples_to_train;
		
	if (new_num_base_models > 0)
	{
		init_num_base_models = num_base_models = new_num_base_models;
		
		// For the code below, see if you can just set up 'basemodels'
		// as a *nnbp and then do basemodels[i] = new nnbp(blah, blah)
		// for each i. This way, you can call the explicit-value
		// constructor for all the base models rather than all these
		// setter functions.
		basemodels = new nnbp[init_num_base_models];
		
		for (int i = 0; i < init_num_base_models; i++)
		{
			if (new_num_hidden > 0)
			{
				basemodels[i].set_num_hidden(new_num_hidden);
			}
			
			basemodels[i].set_training_file(training_examples);
			
			if (new_num_epochs > 0)
			{
				basemodels[i].set_num_epochs(new_num_epochs);
			}
			
			basemodels[i].set_learning_rate(newlearningrate);
			basemodels[i].set_momentum_term(newmomentumterm);
		}
		
		lambda_correct = new double[init_num_base_models];
		lambda_wrong = new double[init_num_base_models];
		epsilons = new double[init_num_base_models];
		betas = new double[init_num_base_models];
		
		for (int t = 0; t < init_num_base_models; t++)
		{
			lambda_correct[t] = 0.0;
			lambda_wrong[t] = 0.0;
			epsilons[t] = 0.0;
			betas[t] = 0.0;
		}
		
		classifications = new ClassNo[init_num_base_models];
		votes = new double[training_examples->NumClasses()];


	}
	else
	{
		std::cout << "ILLEGAL NUMBER OF BASE MODELS: "
				<< new_num_base_models << "\n";
		exit(1);
	}
}


/* set_num_epochs: This function sets the number of epochs in the base models.
*/
void onboostnn::set_num_epochs(int new_num_epochs)
{
	for (int t = 0; t < num_base_models; t++)
	{
		basemodels[t].set_num_epochs(new_num_epochs);
	}
}


/* reset:
This function resets the data structures to make it look as though no
training was done. This means resetting the base models contained within
this ensemble. */
void onboostnn::reset()
{
	for (int t = 0; t < init_num_base_models; t++)
	{
		basemodels[t].reset();
		lambda_correct[t] = 0.0;
		lambda_wrong[t] = 0.0;
		epsilons[t] = 0.0;
		betas[t] = 0.0;
	}
	num_base_models = init_num_base_models; // Forget the fact that we
			// might have chosen to use fewer than the full set of base
			// models.
}
		


// Do batch boosting with examples in datafile
// training_examples.
void onboostnn::trainbatch()
{
	trainbatch(0, training_examples->NumItems());
}

// Do batch training with examples 'first' up to 'last' (these
// are indices into the trainingfile).
void onboostnn::trainbatch(long first, long last)
{
	long numexamples = last-first;
	long* sample = new long[numexamples];
	Description* items = new Description[numexamples];
	Boolean* correctp = new Boolean[numexamples];
	double* weights = new double[numexamples];
	
	// Initialize weights.
	for (int j = 0; j < numexamples; j++)
	{
		weights[j] = 1.0;
	}
	
	// For each base model,...
	for (int i = 0; i < init_num_base_models; i++)
	{
		/* Create training sample according to the weights. The array
		'sample' contains indices into the training examples data
		structure. */
		sample = create_sample(sample, weights, first, last);
		
		for (int j = 0; j < numexamples; j++)
		{
			// Put the jth randomly chosen sample into the items
			// array.
			items[j] = (*training_examples)[sample[j]];
		}
		
		// Now that the sample with replacement is ready, learn
		// the next base model.
		basemodels[i].trainbatch(items, numexamples);
		
		// Now we need to adjust the weights.
		// First determine which examples are being misclassified by
		// the current base model and calculate lambda_wrong[i] (the sum
		// of the weights of the incorrectly classified examples) and
		// lambda_correct[i] (the sum of the weights of the correctly
		// classified examples).
		
		for (int j = first; j < last; j++)
		{
			// If the example is being classified correctly, then...
			if (basemodels[i].test((*training_examples)[j]) ==
				training_examples->TrueClass(j))
			{
				// it is classified correctly,...
				correctp[j-first] = 1;
			}
			else
			{
				// else it is misclassified and its weight needs to be
				// added to lambda_wrong.
				correctp[j-first] = 0;
				lambda_wrong[i] += weights[j-first];
			}
		}
		
		// lambda_correct + lambda_wrong = numexamples. This is equivalent
		// to epsilon + (1 - epsilon) = 1 from AdaBoost.
		lambda_correct[i] = numexamples - lambda_wrong[i];
		
		
		// The following condition is equivalent to epsilon > 1/2 in
		// AdaBoost, i.e., under this condition we stop learning more
		// base models.
		if (lambda_wrong[i] >= numexamples / 2.0)
		{
			num_base_models = i; // Note that init_num_base_models (the
					// number of base models allocated) is still correct.
			return;
		}
		
		if (lambda_wrong[i] == 0.0)
		{
			// If this zero-error base model is the only one we have,
			// then we should use it. Otherwise, we should not use it
			// because it will get all the weight when classifying new
			// examples.
			if (i == 0)
			{
				num_base_models = 1;
				return;
			}
			else
			{
				num_base_models = i;
			}
		}
		
		// Now scale up the weights of misclassified examples and scale
		// down the weights of correctly-classified examples. The method
		// being used is equivalent to AdaBoost's method except that it
		// avoids floating-point problems and does not require a separate
		// normalization step, so it is more efficient.
		for (int j = 0; j < numexamples; j++)
		{
			if (correctp[j])
			{	
				weights[j] *= numexamples / (2.0 * lambda_correct[i]);
			}
			else
			{
				weights[j] *= numexamples / (2.0 * lambda_wrong[i]);
			}
		}
		
		// This is the new weight distribution to be tried.
	}
	
	// We don't need the following data structures specific to the
	// learning algorithm.
	delete [] sample;
	sample = NULL;
	delete [] items;
	items = NULL;
	delete [] correctp;
	correctp = NULL;
	delete [] weights;
	weights = NULL;
}


// Do batch training with examples 'first' up to 'last' (these
// are indices into the trainingfile)--with training file in online mode.
void onboostnn::trainonlinebatch(long first, long last)
{
	long numexamples = last-first;
	long* sampleindices = new long[numexamples]; // Indices into the original sample. We
								// use these to create the actual training sample.
	Description* origsample = new Description[numexamples]; // Original training set
	Description* items = new Description[numexamples]; // Sample for current base model.
	Boolean* correctp = new Boolean[numexamples];
	double* weights = new double[numexamples];
	
	// First create the original sample. We have to create it one-at-a-time because
	// the training set's datafile is in online mode.
	
	for (int j = 0; j < numexamples; j++)
	{
		origsample[j] = training_examples->next_example();
	}
	
	// Initialize weights.
	for (int j = 0; j < numexamples; j++)
	{
		weights[j] = 1.0;
	}
	
	// For each base model,...
	for (int i = 0; i < init_num_base_models; i++)
	{
		/* Create training sample according to the weights. The array
		'sampleindices' contains indices into the training set given in
		origsample. */
		sampleindices = create_sample(sampleindices, weights, first, last);
		
		for (int j = 0; j < numexamples; j++)
		{
			// Put the jth randomly chosen sample into the items
			// array.
			items[j] = origsample[sampleindices[j]];
		}
		
		// Now that the sample with replacement is ready, learn
		// the next base model.
		basemodels[i].trainbatch(items, numexamples);
		
		// Now we need to adjust the weights.
		// First determine which examples are being misclassified by
		// the current base model and calculate lambda_wrong[i] (the sum
		// of the weights of the incorrectly classified examples) and
		// lambda_correct[i] (the sum of the weights of the correctly
		// classified examples).
		
		for (int j = first; j < last; j++)
		{
			// If the example is being classified correctly, then...
			short numattributes = training_examples->return_num_attributes();
			DiscrValue exampleclass = origsample[j][numattributes]._discr_val;
			
			if (basemodels[i].test(origsample[j]) == exampleclass)
			{
				// it is classified correctly,...
				correctp[j-first] = 1;
			}
			else
			{
				// else it is misclassified and its weight needs to be
				// added to lambda_wrong.
				correctp[j-first] = 0;
				lambda_wrong[i] += weights[j-first];
			}
		}
		
		// lambda_correct + lambda_wrong = numexamples. This is equivalent
		// to epsilon + (1 - epsilon) = 1 from AdaBoost.
		lambda_correct[i] = numexamples - lambda_wrong[i];
		
// The following ifdef-endif combination was set up by Nikunj Oza
// 8-2-01 to test when the first base model's performance is < 0.5.		
// #ifdef NO			
		// The following condition is equivalent to epsilon > 1/2 in
		// AdaBoost, i.e., under this condition we stop learning more
		// base models.
		if (lambda_wrong[i] >= numexamples / 2.0)
		{
			if (i == 0)
			{
				num_base_models = 1;
				return;
			}
			else
			{
				num_base_models = i; // Note that init_num_base_models (the
						// number of base models allocated) is still correct.
				return;
			}
		}
// #endif
		
		if (lambda_wrong[i] == 0.0)
		{
			// If this zero-error base model is the only one we have,
			// then we should use it. Otherwise, we should not use it
			// because it will get all the weight when classifying new
			// examples.
			if (i == 0)
			{
				num_base_models = 1;
				return;
			}
			else
			{
				num_base_models = i;
			}
		}
		
		// Now scale up the weights of misclassified examples and scale
		// down the weights of correctly-classified examples. The method
		// being used is equivalent to AdaBoost's method except that it
		// avoids floating-point problems and does not require a separate
		// normalization step, so it is more efficient.
		for (int j = 0; j < numexamples; j++)
		{
			if (correctp[j])
			{	
				weights[j] *= numexamples / (2.0 * lambda_correct[i]);
			}
			else
			{
				weights[j] *= numexamples / (2.0 * lambda_wrong[i]);
			}
		}
		
		// This is the new weight distribution to be tried.
	}
	
	// We don't need the following data structures specific to the
	// learning algorithm.
	delete [] origsample;
	origsample = NULL;
	delete [] sampleindices;
	sampleindices = NULL;
	delete [] items;
	items = NULL;
	delete [] correctp;
	correctp = NULL;
	delete [] weights;
	weights = NULL;
}


// Do online boosting learning with the supplied example
void onboostnn::train(Description example)
{
	double lambda = 1.0;
		
	for (int t = 0; t < num_base_models; t++)
	{
//			cout << "     Updating base model: " << t << endl;
			// Number of times example is to be included.
		long k = poisson(lambda);

		for (int n = 0; n < k; n++)
		{
		// The next line is used for weighted training of the base
		// models.
		//	basemodels[t].train((*training_examples)[i], lambda);
			basemodels[t].train(example);
		}
			
		// Check if example is classified correctly.
		Boolean correctp = (basemodels[t].test(example) == 
						training_examples->TrueClass(example));
			
		// Now update the lambda_correct and lambda_wrong. Also update
		// the weight of the current example.
		if (correctp == 1)
		{
			lambda_correct[t] += lambda;
				
		//	double factor = ((i + 1.0) / (2.0 * lambda_correct[t]));
			double factor = (lambda_correct[t] + lambda_wrong[t]) /
								(2.0 * lambda_correct[t]);
			
			// Since the example has been correctly classified, its
			// weight should be decreased, i.e., its multiplier should
				// be less than 1.0
				
//			lambda *= factor;
// The following ifdef-endif combination was set up by Nikunj Oza
// 8-2-01 to test when the first base model's performance is < 0.5.		
// #ifdef NO	
			if (factor < 1.0)
			{
				lambda *= factor;
			}
			else
			{
				lambda *= 1.0 / (2.0 * (1.0 - exp(-1.0)));
			}
// #endif
		}
		else
		{
			lambda_wrong[t] += lambda;
				
		//	double factor = ((i + 1.0) / (2.0 * lambda_wrong[t]));
			double factor = (lambda_correct[t] + lambda_wrong[t]) /
							(2.0 * lambda_wrong[t]);
				
			// Since the example has been misclassified, its weight
			// should be increased, i.e., its multiplier should be
			// greater than 1.0.
			
//			lambda *= factor;
// The following ifdef-endif combination was set up by Nikunj Oza
// 8-2-01 to test when the first base model's performance is < 0.5.		
// #ifdef NO	
			if (factor > 1.0)
			{
				lambda *= factor;
			}
			else
			{
				 lambda *= 1.0 / (2.0 * exp(-1.0));
			}
// #endif
		}
	}
}

// Do online boosting on the training set in the datafile 
//'training_examples.'
void onboostnn::train()
{
	train(0, training_examples->NumItems());
}

// Do online boosting on the training set in the datafile 
// 'training_examples.' (from 'first' up to 'last,' but not including 
// 'last.')
void onboostnn::train(long first, long last)
{
	for (int i = first; i < last; i++)
	{
//		cout << "Learning example: " << i << endl;
		// Set initial weight.
		double lambda = 1.0;
		
		for (int t = 0; t < num_base_models; t++)
		{
//			cout << "     Updating base model: " << t << endl;
			// Number of times example is to be included.
			long k = poisson(lambda);

			for (int n = 0; n < k; n++)
			{
			// The next line is used for weighted training of the base
			// models.
			//	basemodels[t].train((*training_examples)[i], lambda);
				basemodels[t].train((*training_examples)[i]);
			}
			
			// Check if example is classified correctly.
			Boolean correctp = (basemodels[t].test((*training_examples)[i]) ==
								training_examples->TrueClass(i));
			
			// Now update the lambda_correct and lambda_wrong. Also update
			// the weight of the current example.
			if (correctp == 1)
			{
				lambda_correct[t] += lambda;
				
			//	double factor = ((i + 1.0) / (2.0 * lambda_correct[t]));
				double factor = (lambda_correct[t] + lambda_wrong[t]) /
								(2.0 * lambda_correct[t]);
			
				// Since the example has been correctly classified, its
				// weight should be decreased, i.e., its multiplier should
				// be less than 1.0	
				if (factor < 1.0)
				{
					lambda *= factor;
				}
				else
				{
					 lambda *= 1.0 / (2.0 * (1.0 - exp(-1.0)));
				}
			}
			else
			{
				lambda_wrong[t] += lambda;
				
			//	double factor = ((i + 1.0) / (2.0 * lambda_wrong[t]));
				double factor = (lambda_correct[t] + lambda_wrong[t]) /
								(2.0 * lambda_wrong[t]);
				
				// Since the example has been misclassified, its weight
				// should be increased, i.e., its multiplier should be
				// greater than 1.0.
				if (factor > 1.0)
				{
					lambda *= factor;
				}
				else
				{
					 lambda *= 1.0 / (2.0 * exp(-1.0));
				}
			}
		}
	}
}
			

/* This version of train calculates the errors of each online-updated base model on
all the training examples seen earlier and returns these in one file per base model. This
is to see how "stable" the base models are.
*/
void onboostnn::traintest(long first, long last)
{
	std::vector< std::vector<double> > bmc(num_base_models, std::vector<double>(last-first, 0.0));
	std::vector< std::vector<double> > oberror(num_base_models, std::vector<double>(last-first, 0.0));
	std::vector< std::vector<double> > onlineerror(num_base_models, std::vector<double>(last-first, 0.0));
	
	for (int i = first; i < last; i++)
	{
//		cout << "Learning example: " << i << endl;
		// Set initial weight.
		double lambda = 1.0;
		
		for (int t = 0; t < num_base_models; t++)
		{
//			cout << "     Updating base model: " << t << endl;
			// Number of times example is to be included.
			long k = poisson(lambda);

			for (int n = 0; n < k; n++)
			{
			// The next line is used for weighted training of the base
			// models.
			//	basemodels[t].train((*training_examples)[i], lambda);
				basemodels[t].train((*training_examples)[i]);
			}
			
			// Check if example is classified correctly.
			Boolean correctp = (basemodels[t].test((*training_examples)[i]) ==
								training_examples->TrueClass(i));
			
			// Now update the lambda_correct and lambda_wrong. Also update
			// the weight of the current example.
			if (correctp == 1)
			{
				lambda_correct[t] += lambda;
				
			//	double factor = ((i + 1.0) / (2.0 * lambda_correct[t]));
				double factor = (lambda_correct[t] + lambda_wrong[t]) /
								(2.0 * lambda_correct[t]);
			
				// Since the example has been correctly classified, its
				// weight should be decreased, i.e., its multiplier should
				// be less than 1.0	
				if (factor < 1.0)
				{
					lambda *= factor;
				}
				else
				{
					 lambda *= 1.0 / (2.0 * (1.0 - exp(-1.0)));
				}
			}
			else
			{
				lambda_wrong[t] += lambda;
				
			//	double factor = ((i + 1.0) / (2.0 * lambda_wrong[t]));
				double factor = (lambda_correct[t] + lambda_wrong[t]) /
								(2.0 * lambda_wrong[t]);
				
				// Since the example has been misclassified, its weight
				// should be increased, i.e., its multiplier should be
				// greater than 1.0.
				if (factor > 1.0)
				{
					lambda *= factor;
				}
				else
				{
					 lambda *= 1.0 / (2.0 * exp(-1.0));
				}
			}
			
			
			// We will calculate the "online-batch" error (the error on all past training
			// examples of the latest online base model.
			
			// We will also update the bmc (base model classification error) here.
			
			// Now, go through the previously-seen examples and test the base model
			// on each of them.
			for (int j = first; j <= i; j++)
			{
				Boolean correctp = (basemodels[t].test((*training_examples)[j]) ==
								training_examples->TrueClass(j));
				
				if (correctp == 0)
				{
					oberror[t][i] += 1.0;
				}
				else
				{
					bmc[t][j] += 1.0;
				}
			}
			
			// Now divide by the number of examples seen earlier.
			oberror[t][i] /= (i+1)-first;
						
			// Calculate the online error.
			onlineerror[t][i] = lambda_wrong[t] / (lambda_correct[t] + lambda_wrong[t]);
		}
	}
	
	// Normalize bmc by dividing by the number of base models that have been evaluated
	// on example j.
	for (int t = 0; t < num_base_models; t++)
	{
		for (int j = first; j < last; j++)
		{
			bmc[t][j] /= (last-j);
		}
	}
	
	// Open the file where the classification results are to be placed.
	char basemodelnum[100];
	
	for (int t = 0; t < num_base_models; t++)
	{
		sprintf(basemodelnum, "%d\0", t+1);
		std::string baseclassesfilename = "classifications";
		baseclassesfilename = baseclassesfilename + basemodelnum;
			
		// Stupid additional code required for this to work under GCC.
		// GCC has an obviously incorrect implementation of the string library.
		// I.e., the function string::data() is supposed to return a char* version of 
		// the string, but it instead nondeterministically returns some corrupted version
		// of the string. For this reason, we have to create the char* versions manually.
		char* bcfchars = new char[baseclassesfilename.size()+1];
		
		for (int m = 0; m < baseclassesfilename.size(); m++)
		{
			bcfchars[m] = baseclassesfilename[m];
		}
		bcfchars[baseclassesfilename.size()] = '\0';
		// End of code needed to spoonfeed GNU C++.
			
		std::ofstream baseclasses(bcfchars, ios::app);
		//baseclasses.seekp(0,ios::end);
		delete [] bcfchars;
	
		for (int j = first; j < last; j++)
		{
			baseclasses << bmc[t][j] << " " << oberror[t][j] << " " << onlineerror[t][j] << "\n";
		}
		
		baseclasses.close();
	}
}
			
			

// Do online boosting on the training set in the datafile 
// 'training_examples.' drawn one-at-a-time (from 'first' up to 'last,' 
// but not including 'last.')
void onboostnn::train2(long first, long last)
{
	for (int i = first; i < last; i++)
	{
		Description Item = training_examples->next_example();
//		cout << "Learning example: " << i << endl;
		// Set initial weight.
		double lambda = 1.0;
		
		for (int t = 0; t < num_base_models; t++)
		{
//			cout << "     Updating base model: " << t << endl;
			// Number of times example is to be included.
			long k = poisson(lambda);

			for (int n = 0; n < k; n++)
			{
			// The next line is used for weighted training of the base
			// models.
			//	basemodels[t].train((*training_examples)[i], lambda);
				basemodels[t].train(Item);
			}

			// Check if example is classified correctly.
			Boolean correctp = (basemodels[t].test(Item) ==
								training_examples->TrueClass(Item));
			
			// Now update the lambda_correct and lambda_wrong. Also update
			// the weight of the current example.
			if (correctp == 1)
			{
				lambda_correct[t] += lambda;
				
			//	double factor = ((i + 1.0) / (2.0 * lambda_correct[t]));
				double factor = (lambda_correct[t] + lambda_wrong[t]) /
								(2.0 * lambda_correct[t]);

				// Since the example has been correctly classified, its
				// weight should be decreased, i.e., its multiplier should
				// be less than 1.0					
				if (factor < 1.0)
				{
					lambda *= factor;
				}
				else
				{
					 lambda *= 1.0 / (2.0 * (1.0 - exp(-1.0)));
				}
			}
			else
			{
				lambda_wrong[t] += lambda;
				
			//	double factor = ((i + 1.0) / (2.0 * lambda_wrong[t]));
				double factor = (lambda_correct[t] + lambda_wrong[t]) /
								(2.0 * lambda_wrong[t]);
				
				// Since the example has been misclassified, its weight
				// should be increased, i.e., its multiplier should be
				// greater than 1.0.	
				if (factor > 1.0)
				{
					lambda *= factor;
				}
				else
				{
					 lambda *= 1.0 / (2.0 * exp(-1.0));
				}
			}
		}
	}
}


// Test the example 'instance' using the learned boosted ensemble.
ClassNo onboostnn::test(Description instance)
{
  return test(instance, num_base_models);
}


// Test the example 'instance' using the first 'use_base_models' number
// of base models from the learned boosted ensemble.
ClassNo onboostnn::test(Description instance, long use_base_models)
{
	// Classify the instance using each base model.
	// Recall that 'classifications' contains each base model's
	// classification of the instance. 
	for (int t = 0; t < use_base_models; t++)
	{
		classifications[t] = basemodels[t].test(instance);
	}
	
	// Initialize the weighted votes for each class.
	// votes contains, for each class, the sum of log(1/beta) values
	// by the base models that voted for that class.
	for (int i = 0; i < training_examples->NumClasses(); i++)
	{
		votes[i] = 0.0;
	}

	// Calculate the epsilons and then beta values needed to weight the
	// votes of each base model.
	
	for (int t = 0; t < use_base_models; t++)
	{
		epsilons[t] = lambda_wrong[t] / (lambda_wrong[t] + lambda_correct[t]);
		
		if (epsilons[t] == 1.0)
		{
			betas[t] = FLT_MAX; // If error is maximized, then maximize beta,
						// thereby giving this base model very low weight.
		}
		else
		{
			betas[t] = epsilons[t] / (1.0 - epsilons[t]);
		}
	}
	
	// The trigger is set up so that if the mth base model has an error of
	// more than 0.5, we don't use it or any subsequent base models to
	// classify new examples.
	int trigger = 0;
	// Add up the log(1/beta) values for each class.
	for (int t = 0; t < use_base_models; t++)
	{
//		if (!((betas[t] >= 1.0) || (betas[t] == 0.0)))
//		{
//			votes[classifications[t]] += log(1.0 / betas[t]);
//		}
// The following ifdef-endif combination was set up by Nikunj Oza
// 8-2-01 to test when the first base model's performance is < 0.5.		
// #ifdef NO	
		if ( !((betas[t] >= 1.0) || (betas[t] == 0.0) || (trigger == 1)))
		{
			votes[classifications[t]] += log(1.0 / betas[t]);
		}
		
		if (betas[t] >= 1.0)
		{
			trigger = 1;
		}
// #endif
	}
	
	int answer = argmax(votes, training_examples->NumClasses());	
	return answer;
}


/* create_sample:
Inputs: Array of indices (to be overwritten) into the training set, the
weights of each example (THE WEIGHTS ARE POISSON PARAMETERS, i.e., a
'sampleweight' of 1.0 corresponds to an AdaBoost weight of 1.0/n where 'n'
is the number of training examples), and the indices of the first and last
examples to be considered for sampling.
Output: Array of indices into the training set. These indices correspond to
example sampled with replacement according to the supplied weights.
*/
long* onboostnn::create_sample(long* sample, double* sampleweights,
								long first, long last)
{	
	// First we find the sum of the weights---we want to choose a random value
	// from 0 to this sum and choose a training example accordingly.
	double weightssum = sampleweights[0];
	for (int j = 1; j < last-first; j++)
	{
		weightssum += sampleweights[j];
	}
	
	// For each training example, choose a random example out of the
	// entire set of examples.
	for (int i = 0; i < last-first; i++)
	{
		double randdouble = double(rand()) / RAND_MAX * weightssum;
			
		int j = first; // Index to example.
		double sumsofar = sampleweights[0];
		while ((randdouble > sumsofar) && (j < last))
		{
			j++;
			sumsofar += sampleweights[j-first];
		}
		
		// In case, due to rounding error, the weights do not quite
		// add up to 1 and the random number chosen happens to be
		// greater than the weight sum...
		if (j >= last)
		{
			j = last - 1;
		}
		
		// Example j is the one to be included.
		
		sample[i] = j;
	}

	return sample;
}


// The following function returns the beta value for a given base model.
double onboostnn::return_beta(int modelnum)
{
	if (modelnum <= num_base_models)
	{
		return betas[modelnum-1];
	}
	else
	{
		std::cout << "Error in onboostnn::return_beta: The model number entered ("
			<< modelnum << ") is out of range. The range is 1 to " << num_base_models
			<< "\n";
		exit(1);
	}
}


long onboostnn::return_num_base_models()
{
	return num_base_models;
}

Damn, forum rules much...did you read?

I'd suggest that you don't post that many lines of code. You are refering to line numbers, yet you didnt show line numbers....[code=language] [/code] tags would have done the job, I suggest you shrink it down to a small example that has the same problem.

Chris

1. I agree with Freaky_Chris remarks 100%...
2. Qualify ios class name with std:: namespace prefix.
I don't know why but as usually programmers don't believe that compiler diagnostic is the best source of the right solution ;)...

This article has been dead for over six months. Start a new discussion instead.