MLClassListPtr FeatureVectorList::ExtractListOfClasses () const
{
MLClassPtr lastClass = NULL;
map<MLClassPtr,MLClassPtr> ptrIndex;
map<MLClassPtr,MLClassPtr>::iterator ptrIndexItr;
FeatureVectorList::const_iterator idx;
for (idx = begin (); idx != end (); ++idx)
{
FeatureVectorPtr example = *idx;
MLClassPtr newClass = example->MLClass ();
if (newClass == lastClass)
continue;
lastClass = newClass;
ptrIndexItr = ptrIndex.find (newClass);
if (ptrIndexItr == ptrIndex.end ())
{
lastClass = newClass;
ptrIndex.insert (pair<MLClassPtr,MLClassPtr> (newClass, newClass));
}
}
MLClassListPtr classes = new MLClassList ();
for (ptrIndexItr = ptrIndex.begin (); ptrIndexItr != ptrIndex.end (); ++ptrIndexItr)
classes->PushOnBack (ptrIndexItr->first);
return classes;
} /* ExtractListOfClasses */
MLClassListPtr ClassSummaryList::GetListOfClasses () const
{
MLClassListPtr classes = new MLClassList ();
ClassSummaryList::const_iterator idx;
for (idx = begin (); idx != end (); idx++)
classes->AddMLClass ((*idx)->MLClass ());
return classes;
} /* GetListOfClasses */
MLClassListPtr Classifier2::PredictionsThatHaveSubClassifier (ClassProbListPtr predictions)
{
MLClassListPtr classes = new MLClassList ();
ClassProbList::iterator idx;
for (idx = predictions->begin (); idx != predictions->end (); ++idx)
{
ClassProbPtr cp = *idx;
Classifier2Ptr subClassifier = LookUpSubClassifietByClass (cp->classLabel);
if (subClassifier)
classes->PushOnBack (cp->classLabel);
}
return classes;
} /* PredictionsThatHaveSubClassifier */
void ClassSummaryList::SpatialOverlapReport (ostream& o) const
{
KKStr classTitle1, classTitle2;
MLClassListPtr classes = GetListOfClasses ();
classes->ExtractTwoTitleLines (classTitle1, classTitle2);
VectorInt binSizes = LLoydsBinSizes ();
for (kkuint32 binSizeIdx = 0; binSizeIdx < kkuint32 (binSizes.size ()); binSizeIdx++)
{
kkint32 binSize = binSizes[binSizeIdx];
o << endl
<< endl
<< endl
<< "Spatial Overlap Indexes for BinSize[" << binSize << "]" << endl
<< endl
<< "Class" << "\t" << classTitle1 << endl
<< "Name" << "\t" << classTitle2 << endl;
ClassSummaryList::const_iterator idx;
for (idx = begin (); idx != end (); idx++)
{
ClassSummaryPtr cs1 = *idx;
o << cs1->ClassName ();
ClassSummaryList::const_iterator idx2;
for (idx2 = begin (); idx2 != end (); idx2++)
{
ClassSummaryPtr cs2 = *idx2;
if (idx == idx2)
o << "\t" << "-";
else
{
double spatialIndex = SpatialOverlapIndex (binSize, cs1, cs2);
o << "\t" << spatialIndex;
}
}
o << endl;
}
}
delete classes;
} /* SpatialOverlapReport */
int RandomSampleJobList::DetermineCompressedImageCount (FeatureVectorListPtr trainData,
TrainingConfigurationPtr config
)
{
FileDescPtr fileDesc = trainData->FileDesc ();
FeatureVectorListPtr srcImages = trainData->DuplicateListAndContents ();
FeatureVectorListPtr imagesToTrain = new FeatureVectorList (fileDesc, false, log, 10000);
MLClassListPtr mlClasses = srcImages->ExtractListOfClasses ();
{
MLClassList::const_iterator idx;
for (idx = mlClasses->begin (); idx != mlClasses->end (); idx++)
{
MLClassPtr mlClass = *idx;
FeatureVectorListPtr imagesThisClass = srcImages->ExtractImagesForAGivenClass (mlClass);
imagesToTrain->AddQueue (*imagesThisClass);
delete imagesThisClass;
}
}
NormalizationParms normParms (config, *imagesToTrain, log);
normParms.NormalizeImages (imagesToTrain);
ClassAssignments classAssignments (*mlClasses, log);
FeatureVectorListPtr compressedImageList = new FeatureVectorList (fileDesc, true, log, 10000);
BitReduction br (config->SVMparamREF (), fileDesc, trainData->AllFeatures ());
CompressionStats compressionStats
= br.compress (*imagesToTrain,
compressedImageList,
classAssignments
);
int compressedImageCount = compressionStats.num_images_after;
log.Level (10) << "DetermineCompressedImageCount compressedImageCount[" << compressedImageCount << "]" << endl;
delete compressedImageList; compressedImageList = NULL;
delete mlClasses; mlClasses = NULL;
delete imagesToTrain; imagesToTrain = NULL;
delete srcImages; srcImages = NULL;
return compressedImageCount;
} /* DetermineCompressedImageCount */
FileDescConstPtr FeatureFileIO::GetFileDesc (const KKStr& _fileName,
istream& _in,
MLClassListPtr _classes,
kkint32& _estSize,
KKStr& _errorMessage,
RunLog& _log
)
{
_errorMessage = "Driver '" + DriverName () + "' does not implemenet 'GetFileDesc' method.";
_log.Level (10) << endl
<< "FeatureFileIO::GetFileDesc ***ERROR*** " << _errorMessage << endl
<< " _fileName: " << _fileName << endl
<< " _in.flags: " << _in.flags () << endl
<< " _classes : " << _classes->ToCommaDelimitedStr () << endl
<< " _estSize : " << _estSize << endl
<< endl;
_errorMessage = "ROBERTS read_estSize, functionality not implemented.";
return NULL;
}
void BinaryClass::ProcessStatusStr (KKStr statusStr,
MLClassListPtr mlClasses
)
{
KKStr fieldName;
class1 = NULL;
class2 = NULL;
fieldName = statusStr.ExtractToken2 ("\t");
while (!fieldName.Empty ())
{
fieldName.TrimLeft ("\n\r\t ");
fieldName.TrimRight ("\n\r\t ");
fieldName.Upper ();
if (fieldName == "ALLCLASSES")
{
class1 = NULL;
class2 = NULL;
}
else if (fieldName == "BINARYCLASSES")
{
class1 = mlClasses->GetMLClassPtr (statusStr.ExtractToken2 ("\t"));
class2 = mlClasses->GetMLClassPtr (statusStr.ExtractToken2 ("\t"));
if ((class1 == NULL) || (class2== NULL))
{
cout << "Class1 or Class2 == NULL" << endl;
}
else
{
if ((class1->Name ().Empty ()) || (class1->Name ().Empty ()))
{
cout << "Class1Name or Class2Name are empty" << endl;
}
}
}
else if (fieldName == "STATUS")
status = BinaryClassStatusFromStr (statusStr.ExtractToken2 ("\t"));
else if (fieldName == "NUMPROCESSORS")
numProcessors = statusStr.ExtractTokenInt ("\t");
else if (fieldName.CompareIgnoreCase ("FinalResultType") == 0)
resultType = FinalResultTypeFromStr (statusStr.ExtractToken2 ("\t"));
else if (fieldName.CompareIgnoreCase ("ResultsFileName") == 0)
finalResultsFileName = statusStr.ExtractToken2 ("\t");
else if (fieldName.CompareIgnoreCase ("SelectionMethod") == 0)
selectionMethod = SelectionMethodFromStr (statusStr.ExtractToken2 ("\t"));
else if (fieldName.CompareIgnoreCase ("configFileName") == 0)
configFileName = statusStr.ExtractToken2 ("\t");
fieldName = statusStr.ExtractToken2 ("\t");
}
} /* ProcessStatusStr */
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 ClassificationBiasMatrix::ReadSimpleConfusionMatrix (istream& sr,
MLClassListPtr fileClasses
)
{
// 'classes' - The class order that the owner of this object is expecting.
// 'fileClasses' - The order that the classes are stored in the text file.
if ((classes == NULL) || (fileClasses == NULL))
{
KKStr errMsg = "ReadSimpleConfusionMatrix ***ERROR*** The 'Classes' line was never provided.";
runLog.Level (-1) << errMsg << endl;
valid = false;
throw KKException (errMsg);
}
kkint32 classesColIdx = 0;
char buff[10240];
KKStr l;
while (!sr.eof ())
{
sr.getline (buff, sizeof (buff));
l = buff;
l.TrimLeft ();
l.TrimRight ();
if (l.CompareIgnoreCase ("</SimpleConfusionMatrix>") == 0)
break;
KKStr lineName = l.ExtractToken2 ("\t");
if (lineName.CompareIgnoreCase ("DataRow") == 0)
{
if (fileClasses == NULL)
{
KKStr errMsg = "ReadSimpleConfusionMatrix ***ERROR*** 'Classes' was not provided before 'DataRow'.";
runLog.Level (-1) << errMsg << endl;
valid = false;
throw KKException (errMsg);
}
KKStr className = l.ExtractToken2 ("\t");
KKStr data = l.ExtractToken2 ("\t");
MLClassPtr pc = MLClass::CreateNewMLClass (className);
kkint32 classesIdx = classes->PtrToIdx (pc);
kkint32 fileClassesIdx = fileClasses->PtrToIdx (pc);
if (classesIdx < 0)
{
KKStr errMsg = "ReadSimpleConfusionMatrix ***ERROR*** DataRow specifies class[" + className + "] which is not defined by caller";
runLog.Level (-1) << errMsg << endl;
valid = false;
throw KKException (errMsg);
}
if (fileClassesIdx < 0)
{
KKStr errMsg = "ReadSimpleConfusionMatrix ***ERROR*** DataRow specifies class[" + className + "] was not defined in 'Classes' line.";
runLog.Level (-1) << errMsg << endl;
valid = false;
throw KKException (errMsg);
}
kkint32 classesRowIdx = classesIdx;
VectorKKStr dataFields = data.Split (',');
if (dataFields.size () != (kkuint32)numClasses)
{
KKStr errMsg = "ReadSimpleConfusionMatrix ***ERROR*** DataRow Class[" + className + "] number[" + StrFormatInt ((kkint32)dataFields.size (), "ZZZ0") + "] of values provided does not match number of Classes.";
runLog.Level (-1) << errMsg << endl;
valid = false;
throw KKException (errMsg);
}
for (kkint32 c = 0; c < numClasses; c++)
{
pc = fileClasses->IdxToPtr (c);
classesColIdx = classes->PtrToIdx (pc);
VectorKKStr parts = dataFields[c].Split (':');
if (parts.size () > 1)
{
(*counts) [classesRowIdx][classesColIdx] = parts[0].ToDouble ();
(*probabilities)[classesRowIdx][classesColIdx] = parts[1].ToDouble ();
}
}
}
}
} /* ReadSimpleConfusionMatrix */
