void RandomSplitJobManager::RetrieveRandomSplit (int splitNum,
FeatureVectorListPtr& trainData,
FeatureVectorListPtr& testData
)
{
trainData = NULL;
testData = NULL;
if ((splitNum < 0) || (splitNum >= (int)splits->NumOfOrderings ()))
{
log.Level (-1) << endl << endl
<< "RandomSplitJobManager::RetrieveRandomSplit ***ERROR*** Invalid SplitNum[" << splitNum << "]" << endl
<< endl;
return;
}
const
FeatureVectorListPtr ordering = splits->Ordering (splitNum);
trainData = ordering->ManufactureEmptyList (false);
testData = ordering->ManufactureEmptyList (false);
MLClassList::const_iterator classIDX;
for (classIDX = mlClasses->begin (); classIDX != mlClasses->end (); classIDX++)
{
MLClassPtr ic = *classIDX;
FeatureVectorListPtr examplesThisClass = ordering->ExtractExamplesForAGivenClass (ic);
int numTrainExamplesNeeded = (int)(0.5 + (double)(examplesThisClass->QueueSize ()) * (double)splitFraction);
int numExamplesAddToTrainSet = 0;
FeatureVectorList::const_iterator idx;
for (idx = examplesThisClass->begin (); idx != examplesThisClass->end (); idx++)
{
FeatureVectorPtr example = *idx;
if (numExamplesAddToTrainSet < numTrainExamplesNeeded)
{
trainData->PushOnBack (example);
numExamplesAddToTrainSet++;
}
else
{
testData->PushOnBack (example);
}
}
}
} /* RetrieveRandomSplit */
FeatureVectorListPtr FeatureEncoder::CreateEncodedFeatureVector (FeatureVectorList& srcData)
{
if (srcData.AllFieldsAreNumeric ())
return srcData.DuplicateListAndContents ();
FeatureVectorListPtr encodedFeatureVectorList = new FeatureVectorList (destFileDesc, true);
FeatureVectorList::iterator idx;
for (idx = srcData.begin (); idx != srcData.end (); idx++)
{
FeatureVectorPtr srcExample = *idx;
XSpacePtr encodedData = EncodeAExample (srcExample);
kkint32 zed = 0;
FeatureVectorPtr encodedFeatureVector = new FeatureVector (codedNumOfFeatures);
while (encodedData[zed].index != -1)
{
encodedFeatureVector->AddFeatureData (encodedData[zed].index, (float)encodedData[zed].value);
zed++;
}
encodedFeatureVector->MLClass (srcExample->MLClass ());
encodedFeatureVectorList->PushOnBack (encodedFeatureVector);
delete encodedData;
encodedData = NULL;
}
return encodedFeatureVectorList;
} /* CreateEncodedFeatureVector */
void Strip ()
{
bool cancelFlag = false;
bool successful = false;
bool changesMade = false;
RunLog log;
FeatureFileIOPtr driver = FeatureFileIO::FileFormatFromStr ("C45");
MLClassList mlClasses;
FeatureVectorListPtr data =
driver->LoadFeatureFile ("D:\\Pices\\Reports\\FeatureDataFiles\\AllValidatedImages_ForJonathon\\AllValidatedDataNorm.data",
mlClasses,
-1,
cancelFlag,
successful,
changesMade,
log
);
FeatureVectorListPtr stripped = new FeatureVectorList (data->FileDesc (), false);
FeatureVectorList::const_iterator idx;
for (idx = data->begin (); idx != data->end (); ++idx)
{
FeatureVectorPtr fv = *idx;
KKStr fn = fv->ExampleFileName ();
if (fn.StartsWith ("SML") || (fn.StartsWith ("SMP")))
{
}
else
{
stripped->PushOnBack (fv);
}
}
kkuint32 numExamplesWritten = 90;
driver->SaveFeatureFile ("D:\\Pices\\Reports\\FeatureDataFiles\\AllValidatedImages_ForJonathon\\AllValidatedData1209.data",
data->AllFeatures (),
*stripped,
numExamplesWritten,
cancelFlag,
successful,
log
);
}
FeatureVectorListPtr FeatureEncoder::EncodeAllExamples (const FeatureVectorListPtr srcData)
{
FileDescConstPtr encodedFileDesc = CreateEncodedFileDesc (NULL);
FeatureVectorListPtr encodedExamples = new FeatureVectorList (encodedFileDesc, true);
FeatureVectorList::const_iterator idx;
for (idx = srcData->begin (); idx != srcData->end (); idx++)
{
const FeatureVectorPtr srcExample = *idx;
FeatureVectorPtr encodedExample = EncodeAExample (encodedFileDesc, srcExample);
encodedExamples->PushOnBack (encodedExample);
}
return encodedExamples;
} /* EncodeAllExamples */
void FeatureFileIO::SaveFeatureFileMultipleParts (const KKStr& _fileName,
FeatureNumListConst& _selFeatures,
FeatureVectorList& _examples,
VolConstBool& _cancelFlag,
bool& _successful,
RunLog& _log
)
{
kkuint32 numExamplesWritten = 0;
SaveFeatureFile (_fileName, _selFeatures, _examples, numExamplesWritten, _cancelFlag, _successful, _log);
if (_cancelFlag || (!_successful))
return;
if (_examples.QueueSize () > 64000)
{
kkint32 numPartsNeeded = (_examples.QueueSize () / 64000);
if ((_examples.QueueSize () % 64000) > 0)
numPartsNeeded++;
kkuint32 maxPartSize = (_examples.QueueSize () / numPartsNeeded) + 1;
kkint32 partNum = 0;
FeatureVectorList::const_iterator idx = _examples.begin ();
while ((idx != _examples.end ()) && (_successful) && (!_cancelFlag))
{
FeatureVectorListPtr part = _examples.ManufactureEmptyList (false);
while ((idx != _examples.end ()) && (part->QueueSize () < maxPartSize))
{
part->PushOnBack (*idx);
idx++;
}
KKStr partFileName = osRemoveExtension (_fileName) + "-" +
StrFormatInt (partNum, "00") + "." +
osGetFileExtension (_fileName);
SaveFeatureFile (partFileName, _selFeatures, *part, numExamplesWritten, _cancelFlag, _successful, _log);
partNum++;
delete part; part = NULL;
}
}
} /* SaveFeatureFileMultipleParts */
FeatureVectorListPtr FeatureEncoder2::EncodeAllExamples (const FeatureVectorListPtr srcData)
{
FeatureVectorListPtr encodedExamples = new FeatureVectorList (encodedFileDesc,
true // Will own the contents
);
FeatureVectorList::const_iterator idx;
for (idx = srcData->begin (); idx != srcData->end (); idx++)
{
const FeatureVectorPtr srcExample = *idx;
FeatureVectorPtr encodedExample = EncodeAExample (srcExample);
encodedExamples->PushOnBack (encodedExample);
}
return encodedExamples;
} /* EncodeAllImages */
FeatureVectorListPtr FeatureEncoder2::EncodedFeatureVectorList (const FeatureVectorList& srcData) const
{
if (srcData.AllFieldsAreNumeric ())
return srcData.DuplicateListAndContents ();
FeatureVectorListPtr encodedFeatureVectorList = new FeatureVectorList (encodedFileDesc, true);
FeatureVectorList::const_iterator idx;
for (idx = srcData.begin (); idx != srcData.end (); idx++)
{
FeatureVectorPtr srcExample = *idx;
FeatureVectorPtr encodedFeatureVector = EncodeAExample (srcExample);
encodedFeatureVector->MLClass (srcExample->MLClass ());
encodedFeatureVectorList->PushOnBack (encodedFeatureVector);
}
return encodedFeatureVectorList;
} /* EncodedFeatureVectorList */
void SplitForestCoverFile ()
{
RunLog log;
MLClassConstList mlClasses;
bool cancelFlag = false;
bool successful;
bool changesMade = false;
FeatureVectorListPtr images = FeatureFileIOC45::Driver ()->LoadFeatureFile
("covtype_alpha.data", mlClasses, -1, cancelFlag, successful, changesMade, log);
FileDescPtr fileDesc = images->FileDesc ();
images->RandomizeOrder ();
images->RandomizeOrder ();
images->RandomizeOrder ();
images->RandomizeOrder ();
images->RandomizeOrder ();
MLClassConstPtr lodgepolePine = mlClasses.GetMLClassPtr ("Lodgepole_Pine");
MLClassConstPtr spruceFir = mlClasses.GetMLClassPtr ("Spruce_Fir");
int lodgepolePineTrainCount = 0;
int spruceFirTrainCount = 0;
FeatureVectorList::iterator idx;
FeatureVectorListPtr trainData = new FeatureVectorList (fileDesc, false, log, 10000);
FeatureVectorListPtr testData = new FeatureVectorList (fileDesc, false, log, 10000);
int c = 0;
for (idx = images->begin (); idx != images->end (); idx++)
{
FeatureVectorPtr i = *idx;
if (c % 5000)
cout << c << endl;
if (i->MLClass () == lodgepolePine)
{
if (lodgepolePineTrainCount < 56404)
{
trainData->PushOnBack (i);
lodgepolePineTrainCount++;
}
else
{
testData->PushOnBack (i);
}
}
else if (i->MLClass () == spruceFir)
{
if (spruceFirTrainCount < 42480)
{
trainData->PushOnBack (i);
spruceFirTrainCount++;
}
else
{
testData->PushOnBack (i);
}
}
c++;
}
KKU::uint numExamplesWritten = 0;
FeatureFileIOC45::Driver ()->SaveFeatureFile
("CovType_TwoClass.data",
trainData->AllFeatures (),
*trainData,
numExamplesWritten,
cancelFlag,
successful,
log
);
FeatureFileIOC45::Driver ()->SaveFeatureFile
("CovType_TwoClass.test",
testData->AllFeatures (),
*testData,
numExamplesWritten,
cancelFlag,
successful,
log
);
delete trainData;
delete testData;
delete images;
} /* SplitForestCoverFile */
void FeatureFileConverter::ConvertData ()
{
cout << endl
<< "Saving [" << data->QueueSize () << "] records to data file[" << destFileName << "]" << endl
<< endl;
bool successful = false;
int numOfFeatures = data->NumOfFeatures ();
int numWithAllZeros = 0;
{
FeatureVectorListPtr newData = new FeatureVectorList (srcFileDesc, true, log);
// Will store examples that have all zero's for all features in "zeroData"
// container. This way they can be deleted from memory later and not result
// in a memory leak. This has to be done because they are not going to
// be placed into newData which is going to become the owner of all the
// examples.
FeatureVectorListPtr zeroData = new FeatureVectorList (srcFileDesc, true, log);
// How many have all 0's for feature data.
FeatureVectorList::iterator idx;
for (idx = data->begin (); idx != data->end (); idx++)
{
FeatureVectorPtr i = *idx;
bool allZeros = true;
for (int featureNum = 0; featureNum < numOfFeatures; featureNum++)
{
allZeros = (i->FeatureData (featureNum) == 0.0f);
if (!allZeros)
break;
}
if (allZeros)
{
numWithAllZeros++;
zeroData->PushOnBack (i);
}
else
{
newData->PushOnBack (i);
}
}
data->Owner (false);
delete data;
data = newData;
delete zeroData;
}
*report << endl
<< endl
<< "Num of data items with all zero feature data [" << numWithAllZeros << "]" << endl
<< endl;
*report << data->ClassStatisticsStr ();
*report << endl << endl << endl;
if (statistics)
{
*report << "Class Statistics:" << endl;
data->PrintClassStatistics (*report);
*report << endl << endl;
*report << "Feature Statistics:" << endl;
data->PrintFeatureStatisticsByClass (*report);
}
if (enumerateClasses)
{
// We are going to change the name of the classes to numbers enumberated by className
MLClassConstListPtr mlClasses = data->ExtractMLClassConstList ();
mlClasses->SortByName ();
MLClassConstListPtr newClassNames = new MLClassConstList ();
int classIdx = 0;
MLClassConstList::iterator idx;
for (idx = mlClasses->begin (); idx != mlClasses->end (); idx++)
{
KKStr newName = StrFormatInt (classIdx, "zzz0");
MLClassConstPtr mlClass = newClassNames->GetMLClassPtr (newName);
classIdx++;
}
FeatureVectorList::iterator idx2;
for (idx2 = data->begin (); idx2 != data->end (); idx2++)
{
MLClassConstPtr c = (*idx2)->MLClass ();
int classIndex = mlClasses->PtrToIdx (c);
(*idx2)->MLClass (newClassNames->IdxToPtr (classIndex));
}
delete mlClasses; mlClasses = NULL;
delete newClassNames; newClassNames = NULL;
}
if (encodeFeatureData)
{
EncodeFeatureData ();
}
else
{
uint numExamplesWritten = 0;
destFileFormat->SaveFeatureFile (destFileName,
*features,
*data,
numExamplesWritten,
cancelFlag,
successful,
log
);
}
} /* ConvertData */
FeatureVectorListPtr FeatureFileIO::FeatureDataReSink (FactoryFVProducerPtr _fvProducerFactory,
const KKStr& _dirName,
const KKStr& _fileName,
MLClassPtr _unknownClass,
bool _useDirectoryNameForClassName,
MLClassList& _mlClasses,
VolConstBool& _cancelFlag,
bool& _changesMade,
KKB::DateTime& _timeStamp,
RunLog& _log
)
{
_changesMade = false;
_timeStamp = DateTime ();
if (_unknownClass == NULL)
_unknownClass = MLClass::GetUnKnownClassStatic ();
KKStr className = _unknownClass->Name ();
_log.Level (10) << "FeatureFileIO::FeatureDataReSink dirName: " << _dirName << endl
<< " fileName: " << _fileName << " UnKnownClass: " << className << endl;
KKStr fullFeatureFileName = osAddSlash (_dirName) + _fileName;
bool successful = true;
KKStr fileNameToOpen;
if (_dirName.Empty ())
fileNameToOpen = _fileName;
else
fileNameToOpen = osAddSlash (_dirName) + _fileName;
bool versionsAreSame = false;
FeatureVectorListPtr origFeatureVectorData
= LoadFeatureFile (fileNameToOpen, _mlClasses, -1, _cancelFlag, successful, _changesMade, _log);
if (origFeatureVectorData == NULL)
{
successful = false;
origFeatureVectorData = _fvProducerFactory->ManufacturFeatureVectorList (true);
}
if (_cancelFlag)
{
delete origFeatureVectorData; origFeatureVectorData = NULL;
return _fvProducerFactory->ManufacturFeatureVectorList (true);
}
FeatureVectorListPtr origFeatureData = NULL;
if (successful &&
(&typeid (*origFeatureVectorData) == _fvProducerFactory->FeatureVectorListTypeId ()) &&
((*(origFeatureVectorData->FileDesc ())) == (*(_fvProducerFactory->FileDesc ())))
)
{
origFeatureData = origFeatureVectorData;
}
else
{
origFeatureData = _fvProducerFactory->ManufacturFeatureVectorList (true);
delete origFeatureVectorData;
origFeatureVectorData = NULL;
}
KKStr fileSpec = osAddSlash (_dirName) + "*.*";
KKStrListPtr fileNameList = osGetListOfFiles (fileSpec);
if (!fileNameList)
{
// There are no Image Files, so we need to return a Empty List of Image Features.
if (origFeatureData->QueueSize () > 0)
_changesMade = true;
delete origFeatureData; origFeatureData = NULL;
return _fvProducerFactory->ManufacturFeatureVectorList (true);
}
FeatureVectorProducerPtr fvProducer = _fvProducerFactory->ManufactureInstance (_log);
if (successful)
{
if (origFeatureData->Version () == fvProducer->Version ())
{
versionsAreSame = true;
_timeStamp = osGetFileDateTime (fileNameToOpen);
}
else
{
_changesMade = true;
}
}
else
{
delete origFeatureData;
origFeatureData = _fvProducerFactory->ManufacturFeatureVectorList (true);
}
origFeatureData->SortByRootName (false);
FeatureVectorListPtr extractedFeatures = _fvProducerFactory->ManufacturFeatureVectorList (true);
extractedFeatures->Version (fvProducer->Version ());
fileNameList->Sort (false);
KKStrList::iterator fnIDX;
fnIDX = fileNameList->begin (); // fileNameList
KKStrPtr imageFileName;
kkuint32 numImagesFoundInOrigFeatureData = 0;
kkuint32 numOfNewFeatureExtractions = 0;
for (fnIDX = fileNameList->begin (); (fnIDX != fileNameList->end ()) && (!_cancelFlag); ++fnIDX)
{
imageFileName = *fnIDX;
// pv414-_002_20140414-162243_02068814-1261.bmp
KKStr rootName = osGetRootName (*imageFileName);
if (rootName == "pv414-_002_20140414-162243_02068814-1261")
cout << "Stop Here." << endl;
bool validImageFileFormat = SupportedImageFileFormat (*imageFileName);
if (!validImageFileFormat)
continue;
bool featureVectorCoputaionSuccessful = false;
FeatureVectorPtr origFV = origFeatureData->BinarySearchByName (*imageFileName);
if (origFV)
numImagesFoundInOrigFeatureData++;
if (origFV && versionsAreSame)
{
featureVectorCoputaionSuccessful = true;
if (_useDirectoryNameForClassName)
{
if (origFV->MLClass () != _unknownClass)
{
_changesMade = true;
origFV->MLClass (_unknownClass);
}
}
else if ((origFV->MLClass ()->UnDefined ()) && (origFV->MLClass () != _unknownClass))
{
_changesMade = true;
origFV->MLClass (_unknownClass);
}
extractedFeatures->PushOnBack (origFV);
origFeatureData->DeleteEntry (origFV);
}
else
{
// We either DON'T have an original image or versions are not the same.
KKStr fullFileName = osAddSlash (_dirName) + (*imageFileName);
FeatureVectorPtr fv = NULL;
try
{
RasterPtr image = ReadImage (fullFileName);
if (image)
fv = fvProducer->ComputeFeatureVector (*image, _unknownClass, NULL, 1.0f, _log);
delete image;
image = NULL;
if (fv)
featureVectorCoputaionSuccessful = true;
else
featureVectorCoputaionSuccessful = false;
}
catch (...)
{
_log.Level (-1) << endl << endl
<< "FeatureDataReSink ***ERROR***" << endl
<< " Exception occurred calling constructor 'ComputeFeatureVector'." << endl
<< endl;
featureVectorCoputaionSuccessful = false;
fv = NULL;
}
if (!featureVectorCoputaionSuccessful)
{
_log.Level (-1) << " FeatureFileIOKK::FeatureDataReSink *** ERROR ***, Processing Image File["
<< imageFileName << "]."
<< endl;
delete fv;
fv = NULL;
}
else
{
_changesMade = true;
fv->ExampleFileName (*imageFileName);
_log.Level (30) << fv->ExampleFileName () << " " << fv->OrigSize () << endl;
extractedFeatures->PushOnBack (fv);
numOfNewFeatureExtractions++;
if ((numOfNewFeatureExtractions % 100) == 0)
cout << numOfNewFeatureExtractions << " Images Extracted." << endl;
}
}
}
if (numImagesFoundInOrigFeatureData != extractedFeatures->QueueSize ())
_changesMade = true;
extractedFeatures->Version (fvProducer->Version ());
if ((_changesMade) && (!_cancelFlag))
{
//extractedFeatures->WriteImageFeaturesToFile (fullFeatureFileName, RawFormat, FeatureNumList::AllFeatures (extractedFeatures->FileDesc ()));
kkuint32 numExamplesWritten = 0;
SaveFeatureFile (fullFeatureFileName,
FeatureNumList::AllFeatures (extractedFeatures->FileDesc ()),
*extractedFeatures,
numExamplesWritten,
_cancelFlag,
successful,
_log
);
_timeStamp = osGetLocalDateTime ();
}
delete fvProducer; fvProducer = NULL;
delete fileNameList; fileNameList = NULL;
delete origFeatureData; origFeatureData = NULL;
_log.Level (10) << "FeatureDataReSink Exiting Dir: " << _dirName << endl;
return extractedFeatures;
} /* FeatureDataReSink */
void RandomSampleJob::EvaluteNode (FeatureVectorListPtr validationData,
MLClassListPtr classes
)
{
log.Level (9) << " " << endl;
log.Level (9) << " " << endl;
log.Level (9) << "RandomSampleJob::EvaluteNode JobId[" << jobId << "] Ordering[" << orderingNum << "]" << endl;
status = rjStarted;
config->CompressionMethod (BRnoCompression);
config->KernalType (kernelType);
config->EncodingMethod (encodingMethod);
config->C_Param (c);
config->Gamma (gamma);
FileDescPtr fileDesc = config->FileDesc ();
const FeatureVectorListPtr srcExamples = orderings->Ordering (orderingNum);
if (numExamplesToKeep > srcExamples->QueueSize ())
{
log.Level (-1) << endl << endl << endl
<< "RandomSampleJob::EvaluteNode *** ERROR *** RandomExamples to large" << endl
<< endl
<< " RandomExamples > num in Training set." << endl
<< endl;
osWaitForEnter ();
exit (-1);
}
FeatureVectorListPtr trainingData = new FeatureVectorList (srcExamples->FileDesc (), false, log, 10000);
for (int x = 0; x < numExamplesToKeep; x++)
{
trainingData->PushOnBack (srcExamples->IdxToPtr (x));
}
bool allClassesRepresented = true;
{
MLClassListPtr classesInRandomSample = trainingData->ExtractListOfClasses ();
if (*classesInRandomSample != (*classes))
{
log.Level (-1) << endl << endl
<< "RandomSampling *** ERROR ***" << endl
<< endl
<< " Missing Classes From Random Sample." << endl
<< endl
<< "MLClasses[" << classes->ToCommaDelimitedStr () << "]" << endl
<< "Found [" << classesInRandomSample->ToCommaDelimitedStr () << "]" << endl
<< endl;
allClassesRepresented = false;
}
delete classesInRandomSample; classesInRandomSample = NULL;
}
//if (!allClassesRepresented)
//{
// accuracy = 0.0;
// trainTime = 0.0;
// testTime = 0.0;
//}
//else
{
delete crossValidation; crossValidation = NULL;
compMethod = config->CompressionMethod ();
bool cancelFlag = false;
crossValidation = new CrossValidation
(config,
trainingData,
classes,
10,
false, // False = Features are not normalized already.
trainingData->FileDesc (),
log,
cancelFlag
);
crossValidation->RunValidationOnly (validationData, NULL);
accuracy = crossValidation->Accuracy ();
trainTime = crossValidation->TrainTimeMean ();
testTime = crossValidation->TestTimeMean ();
supportVectors = crossValidation->SupportPointsMean ();
}
delete trainingData;
status = rjDone;
} /* EvaluteNode */
void AbundanceCorrectionStatsBuilder::CreateInitialThreadInstaces ()
{
log.Level (10) << "AbundanceCorrectionStatsBuilder::CreateInitialThreadInstaces" << endl;
FeatureVectorListPtr stratifiedTrainData = trainLibData->StratifyAmoungstClasses (numOfFolds);
FeatureVectorListPtr stratifiedOtherData = otherClassData->StratifyAmoungstClasses (numOfFolds);
int32 numTrainExamples = stratifiedTrainData->QueueSize ();
int32 numOtherExamples = stratifiedOtherData->QueueSize ();
msgQueue = new MsgQueue ("AbundanceCorrectionStatsBuilder");
int32 lastFvInFold = -1;
int32 firstFvInFold = 0;
int32 firstOtherFvInFold = 0;
int32 lastOtherFvInFold = -1;
for (int32 foldNum = 0; foldNum < numOfFolds; ++foldNum)
{
firstFvInFold = lastFvInFold + 1;
lastFvInFold = (numTrainExamples * (foldNum + 1) / numOfFolds) - 1;
firstOtherFvInFold = lastOtherFvInFold + 1;
lastOtherFvInFold = (numOtherExamples * (foldNum + 1) / numOfFolds) - 1;
FeatureVectorListPtr trainData = new FeatureVectorList (fileDesc, false, log);
FeatureVectorListPtr testData = new FeatureVectorList (fileDesc, false, log);
for (int32 idx = 0; idx < numTrainExamples; ++idx)
{
FeatureVectorPtr fv = stratifiedTrainData->IdxToPtr (idx);
if ((idx >= firstFvInFold) && (idx <= lastFvInFold))
testData->PushOnBack (fv);
else
trainData->PushOnBack (fv);
}
// Add OtherClass exampes to test data.
for (int32 idx = firstOtherFvInFold; idx <= lastOtherFvInFold; ++idx)
{
FeatureVectorPtr fv = stratifiedOtherData->IdxToPtr (idx);
testData->PushOnBack (fv);
}
RunLogPtr threadRunLog = new RunLog ();
threadRunLog->AttachMsgQueue (msgQueue);
KKStr threadName = "AbundanceCorrFold" + StrFormatInt (foldNum, "00");
TrainTestThreadPtr thread = new TrainTestThread
("Fold_" + StrFormatInt (foldNum, "00"),
this,
config,
allClasses,
trainData, // Will take ownesrship and delete in its destructor.
trainLibDataClasses,
testData, // Will take ownesrship and delete in its destructor.
otherClass,
threadName,
msgQueue, // Will take ownesrship and delete in its destructor.
threadRunLog
);
queueReady->PushOnBack (thread);
}
delete stratifiedOtherData; stratifiedOtherData = NULL;
delete stratifiedTrainData; stratifiedTrainData = NULL;
} /* CreateInitialThreadInstaces */
