bool RegressionTree::train_(RegressionData &trainingData){
//Clear any previous model
clear();
const unsigned int M = trainingData.getNumSamples();
const unsigned int N = trainingData.getNumInputDimensions();
const unsigned int T = trainingData.getNumTargetDimensions();
if( M == 0 ){
Regressifier::errorLog << "train_(RegressionData &trainingData) - Training data has zero samples!" << std::endl;
return false;
}
numInputDimensions = N;
numOutputDimensions = T;
inputVectorRanges = trainingData.getInputRanges();
targetVectorRanges = trainingData.getTargetRanges();
//Scale the training data if needed
if( useScaling ){
//Scale the training data between 0 and 1
trainingData.scale(0, 1);
}
//Setup the valid features - at this point all features can be used
Vector< UINT > features(N);
for(UINT i=0; i<N; i++){
features[i] = i;
}
//Build the tree
UINT nodeID = 0;
tree = buildTree( trainingData, NULL, features, nodeID );
if( tree == NULL ){
clear();
Regressifier::errorLog << "train_(RegressionData &trainingData) - Failed to build tree!" << std::endl;
return false;
}
//Flag that the algorithm has been trained
trained = true;
return true;
}
bool LogisticRegression::train_(RegressionData &trainingData){
const unsigned int M = trainingData.getNumSamples();
const unsigned int N = trainingData.getNumInputDimensions();
const unsigned int K = trainingData.getNumTargetDimensions();
trained = false;
trainingResults.clear();
if( M == 0 ){
errorLog << "train_(RegressionData trainingData) - Training data has zero samples!" << endl;
return false;
}
if( K == 0 ){
errorLog << "train_(RegressionData trainingData) - The number of target dimensions is not 1!" << endl;
return false;
}
numInputDimensions = N;
numOutputDimensions = 1; //Logistic Regression will have 1 output
inputVectorRanges.clear();
targetVectorRanges.clear();
//Scale the training and validation data, if needed
if( useScaling ){
//Find the ranges for the input data
inputVectorRanges = trainingData.getInputRanges();
//Find the ranges for the target data
targetVectorRanges = trainingData.getTargetRanges();
//Scale the training data
trainingData.scale(inputVectorRanges,targetVectorRanges,0.0,1.0);
}
//Reset the weights
Random rand;
w0 = rand.getRandomNumberUniform(-0.1,0.1);
w.resize(N);
for(UINT j=0; j<N; j++){
w[j] = rand.getRandomNumberUniform(-0.1,0.1);
}
double error = 0;
double lastSquaredError = 0;
double delta = 0;
UINT iter = 0;
bool keepTraining = true;
Random random;
vector< UINT > randomTrainingOrder(M);
TrainingResult result;
trainingResults.reserve(M);
//In most cases, the training data is grouped into classes (100 samples for class 1, followed by 100 samples for class 2, etc.)
//This can cause a problem for stochastic gradient descent algorithm. To avoid this issue, we randomly shuffle the order of the
//training samples. This random order is then used at each epoch.
for(UINT i=0; i<M; i++){
randomTrainingOrder[i] = i;
}
std::random_shuffle(randomTrainingOrder.begin(), randomTrainingOrder.end());
//Run the main stochastic gradient descent training algorithm
while( keepTraining ){
//Run one epoch of training using stochastic gradient descent
totalSquaredTrainingError = 0;
for(UINT m=0; m<M; m++){
//Select the random sample
UINT i = randomTrainingOrder[m];
//Compute the error, given the current weights
VectorDouble x = trainingData[i].getInputVector();
VectorDouble y = trainingData[i].getTargetVector();
double h = w0;
for(UINT j=0; j<N; j++){
h += x[j] * w[j];
}
error = y[0] - sigmoid( h );
totalSquaredTrainingError += SQR(error);
//Update the weights
for(UINT j=0; j<N; j++){
w[j] += learningRate * error * x[j];
}
w0 += learningRate * error;
}
//Compute the error
delta = fabs( totalSquaredTrainingError-lastSquaredError );
lastSquaredError = totalSquaredTrainingError;
//Check to see if we should stop
if( delta <= minChange ){
keepTraining = false;
}
if( ++iter >= maxNumEpochs ){
keepTraining = false;
}
if( std::isinf( totalSquaredTrainingError ) || std::isnan( totalSquaredTrainingError ) ){
errorLog << "train_(RegressionData &trainingData) - Training failed! Total squared error is NAN. If scaling is not enabled then you should try to scale your data and see if this solves the issue." << endl;
return false;
}
//Store the training results
rootMeanSquaredTrainingError = sqrt( totalSquaredTrainingError / double(M) );
result.setRegressionResult(iter,totalSquaredTrainingError,rootMeanSquaredTrainingError,this);
trainingResults.push_back( result );
//Notify any observers of the new result
trainingResultsObserverManager.notifyObservers( result );
trainingLog << "Epoch: " << iter << " SSE: " << totalSquaredTrainingError << " Delta: " << delta << endl;
}
//Flag that the algorithm has been trained
regressionData.resize(1,0);
trained = true;
return trained;
}
bool MultidimensionalRegression::train_(RegressionData &trainingData){
const unsigned int M = trainingData.getNumSamples();
const unsigned int N = trainingData.getNumInputDimensions();
const unsigned int K = trainingData.getNumTargetDimensions();
trained = false;
trainingResults.clear();
deleteRegressionModules();
if( !getIsRegressionModuleSet() ){
errorLog << "train_(RegressionData &trainingData) - The regression module has not been set!" << std::endl;
return false;
}
if( M == 0 ){
errorLog << "train_(RegressionData &trainingData) - Training data has zero samples!" << std::endl;
return false;
}
numInputDimensions = N;
numOutputDimensions = K;
inputVectorRanges.clear();
targetVectorRanges.clear();
//Scale the training and validation data, if needed
if( useScaling ){
//Find the ranges for the input data
inputVectorRanges = trainingData.getInputRanges();
//Find the ranges for the target data
targetVectorRanges = trainingData.getTargetRanges();
//Scale the training data
trainingData.scale(inputVectorRanges,targetVectorRanges,0.0,1.0);
}
//Setup the regression modules
regressionModules.resize( K, NULL );
//Any scaling will happpen at the meta level, not the regression module letter, so ensure scaling is turned off for the modules
regressifier->enableScaling( false );
for(UINT k=0; k<K; k++){
regressionModules[k] = regressifier->deepCopy();
if( regressionModules[k] == NULL ){
errorLog << "train(LabelledRegressionData &trainingData) - Failed to deep copy module " << k << std::endl;
return false;
}
}
//Train each regression module
for(UINT k=0; k<K; k++){
trainingLog << "Training regression module: " << k << std::endl;
//We need to create a 1 dimensional training dataset for the k'th target dimension
RegressionData data;
data.setInputAndTargetDimensions(N, 1);
for(UINT i=0; i<M; i++){
if( !data.addSample(trainingData[i].getInputVector(), VectorFloat(1,trainingData[i].getTargetVector()[k]) ) ){
errorLog << "train_(RegressionData &trainingData) - Failed to add sample to dataset for regression module " << k << std::endl;
return false;
}
}
if( !regressionModules[k]->train( data ) ){
errorLog << "train_(RegressionData &trainingData) - Failed to train regression module " << k << std::endl;
return false;
}
}
//Flag that the algorithm has been trained
regressionData.resize(K,0);
trained = true;
return trained;
}
