void ModelParamUsfCasCor::ParseCmdLineParameter (const KKStr& parameter,
const KKStr& value,
bool& parameterUsed,
RunLog& log
)
{
parameterUsed = true;
if (parameter.EqualIgnoreCase ("-InLimit") ||
parameter.EqualIgnoreCase ("-IL") ||
parameter.EqualIgnoreCase ("-I")
)
in_limit = value.ToInt ();
else if (parameter.EqualIgnoreCase ("-OutLimit") ||
parameter.EqualIgnoreCase ("-OL") ||
parameter.EqualIgnoreCase ("-O")
)
out_limit = value.ToInt ();
else if (parameter.EqualIgnoreCase ("-NumberOfRounds") ||
parameter.EqualIgnoreCase ("-NOR") ||
parameter.EqualIgnoreCase ("-Rounds") ||
parameter.EqualIgnoreCase ("-R")
)
number_of_rounds = value.ToInt ();
else if (parameter.EqualIgnoreCase ("-NumberOfTrials") ||
parameter.EqualIgnoreCase ("-NOT") ||
parameter.EqualIgnoreCase ("-T")
)
number_of_trials = value.ToInt ();
else if (parameter.EqualIgnoreCase ("-RandomSeed") ||
parameter.EqualIgnoreCase ("-RS") ||
parameter.EqualIgnoreCase ("-S")
)
random_seed = value.ToInt ();
else if (parameter.EqualIgnoreCase ("-UseCache") ||
parameter.EqualIgnoreCase ("-UC") ||
parameter.EqualIgnoreCase ("-Cache")
)
{
if (value.Empty ())
useCache = true;
else
useCache = value.ToBool ();
}
else
parameterUsed = false;
} /* ParseCmdLineParameter */
void KKJob::ProcessStatusStr (const KKStr& statusStr)
{
log.Level (30) << "KKJob::ProcessStatusStr[" << statusStr << "]" << endl;
KKStr fieldName;
KKStr fieldValue;
VectorKKStr fields = statusStr.Split ('\t');
kkuint32 fieldNum = 0;
while (fieldNum < fields.size ())
{
fieldName = fields[fieldNum];
fieldNum++;
if (fieldNum < fields.size ())
{
fieldValue = fields[fieldNum];
fieldNum++;
}
else
{
fieldValue = "";
}
fieldName.Upper ();
fieldValue.TrimLeft ("\n\r\t ");
fieldValue.TrimRight ("\n\r\t ");
if (fieldName.CompareIgnoreCase ("JOBID") == 0)
jobId = atoi (fieldValue.Str ());
else if (fieldName.CompareIgnoreCase ("PARENTID") == 0)
parentId = atoi (fieldValue.Str ());
else if (fieldName.CompareIgnoreCase ("STATUS") == 0)
status = JobStatusFromStr (fieldValue);
else if (fieldName.CompareIgnoreCase ("NumProcessors") == 0)
numProcessors = fieldValue.ToInt ();
else if (fieldName.CompareIgnoreCase ("NumPorcessesAllowed") == 0)
numPorcessesAllowed = fieldValue.ToInt ();
else if (fieldName.CompareIgnoreCase ("Prerequisites") == 0)
PrerequisitesFromStr (fieldValue);
else
{
ProcessStatusField (fieldName, fieldValue);
}
}
} /* ProcessStatusStr */
void RandomSplitJobManager::StatusFileProcessLine (const KKStr& _ln,
istream& statusFile
)
{
KKStr ln (_ln);
KKStr fieldName = ln.ExtractToken2 ("\t");
KKStr fieldValue = ln.ExtractToken2 ("\t");
if (fieldName.CompareIgnoreCase ("MLClasses") == 0)
mlClasses = MLClassList::BuildListFromDelimtedStr (fieldValue, ',');
else if (fieldName.CompareIgnoreCase ("ConfigFileName") == 0)
configFileName = fieldValue;
else if (fieldName.CompareIgnoreCase ("DataFileName") == 0)
dataFileName = fieldValue;
else if (fieldName.CompareIgnoreCase ("DataIndexFileName") == 0)
dataIndexFileName = fieldValue;
else if (fieldName.CompareIgnoreCase ("Format") == 0)
format = FeatureFileIO::FileFormatFromStr (fieldValue);
else if (fieldName.CompareIgnoreCase ("NumFolds") == 0)
numFolds = fieldValue.ToInt ();
else if (fieldName.CompareIgnoreCase ("NumSplits") == 0)
numSplits = fieldValue.ToInt ();
else if (fieldName.CompareIgnoreCase ("SplitFraction") == 0)
{
bool percentage = (fieldValue.LastChar () == '%');
if (percentage)
{
fieldValue.ChopLastChar ();
splitFraction = fieldValue.ToFloat () / 100.0f;
}
else
{
splitFraction = fieldValue.ToFloat ();
if (splitFraction > 1.0f)
splitFraction = splitFraction / 100.0f;
}
}
else
KKJobManager::StatusFileProcessLine (_ln, statusFile);
} /* StatusFileProcessLine */
bool AbundanceCorrectionStatsBuilder::ProcessCmdLineParameter (char parmSwitchCode,
KKStr parmSwitch,
KKStr parmValue
)
{
KKStr parmValueUpper (parmValue);
parmValueUpper.Upper ();
if (parmSwitch.EqualIgnoreCase ("-c") || parmSwitch.EqualIgnoreCase ("-config"))
{
configFileName = parmValue;
configFileFullPath = TrainingConfiguration2::GetEffectiveConfigFileName (configFileName);
if (!osFileExists (configFileFullPath))
{
log.Level (-1) << "ProcessCmdLineParameter ***ERROR*** Invalid '-config' [" << configFileName << "] file." << endl;
Abort (true);
}
}
else if (parmSwitch.EqualIgnoreCase ("-folds") || parmSwitch.EqualIgnoreCase ("-numFolds") || parmSwitch.EqualIgnoreCase ("-numOfFolds"))
{
numOfFolds = parmValue.ToInt ();
if ((numOfFolds < 2) || (numOfFolds > 1000))
{
log.Level (-1) << "ProcessCmdLineParameter ***ERROR*** Invalid '-NumFolds' [" << numOfFolds << "] Invlaid; valid values (2 - 1000)." << endl;
Abort (true);
}
}
else if (parmSwitch.EqualIgnoreCase ("-r") || parmSwitch.EqualIgnoreCase ("-report") || parmSwitch.EqualIgnoreCase ("-ReportFileName"))
reportFileName = parmValue;
return !Abort ();
} /* ProcessCmdLineParameter */
void ScannerFile::ExtractHeaderField (const KKStr& fieldName,
const KKStr& fieldValue
)
{
if (fieldName.EqualIgnoreCase ("FrameHeight"))
{
kkuint32 fieldValueUint = fieldValue.ToInt32 ();
if ((fieldValueUint > 0) && (fieldValueUint < (1024 * 1024)))
frameHeight = fieldValue.ToInt32 ();
}
else if (fieldName.EqualIgnoreCase ("PixelsPerScanLine"))
pixelsPerScanLine = fieldValue.ToInt ();
else if (fieldName.EqualIgnoreCase ("ScanRate"))
scanRate = fieldValue.ToFloat ();
else if (fieldName.EqualIgnoreCase ("FlatFieldCorrectionEnabled"))
flatFieldEnabled = fieldValue.ToBool ();
} /* ExtractHeaderField */
bool MergeFeatureFiles::ProcessCmdLineParameter (const KKStr& parmSwitch,
const KKStr& parmValue
)
{
bool validParm = true;
if (parmSwitch.EqualIgnoreCase ("-S") ||
parmSwitch.EqualIgnoreCase ("-SRC") ||
parmSwitch.EqualIgnoreCase ("-SOURCE")
)
{
KKStr srcFileName = parmValue;
if (!osFileExists (srcFileName))
{
log.Level (-1) << "ProcessCmdLineParameter ***ERROR*** Invalid '-src' [" << srcFileName << "] file." << endl;
Abort (true);
validParm = false;
}
srcFileNames.push_back (srcFileName);
srcFormats.push_back (currentDefaultFormat);
if (!currentDefaultFormat->CanRead ())
{
log.Level (-1) << "ProcessCmdLineParameter ***ERROR*** Format[" << currentDefaultFormat->DriverName () << "] does not support read." << endl;
Abort (true);
validParm = false;
}
}
else if
(parmSwitch.EqualIgnoreCase ("-DEST") ||
parmSwitch.EqualIgnoreCase ("-D") ||
parmSwitch.EqualIgnoreCase ("-DESTINATION")
)
{
if (!destFileName.Empty ())
{
log.Level (-1) << "ProcessCmdLineParameter ***ERROR*** More than one destination file was specified." << endl;
Abort (true);
validParm= false;
}
destFileName = parmValue;
if (osFileExists (destFileName))
{
log.Level (-1) << "ProcessCmdLineParameter ***ERROR*** Destination File[" << destFileName << "] already exists." << endl;
Abort (true);
validParm = false;
}
if (!currentDefaultFormat->CanWrite ())
{
log.Level (-1) << "ProcessCmdLineParameter ***ERROR*** Format[" << currentDefaultFormat->DriverName () << "] does not support write." << endl;
Abort (true);
validParm = false;
}
destFormat = currentDefaultFormat;
}
else if
(parmSwitch.EqualIgnoreCase ("-F") ||
parmSwitch.EqualIgnoreCase ("-FORMAT")
)
{
FeatureFileIOPtr newFormat = FeatureFileIO::FileFormatFromStr (parmValue);
if (!newFormat)
{
log.Level (-1) << "ProcessCmdLineParameter ***ERROR*** No such format as[" << parmValue<< "]." << endl;
Abort (true);
validParm = false;
}
else
{
currentDefaultFormat = newFormat;
}
}
else if
(parmSwitch.EqualIgnoreCase ("-STRAT") ||
parmSwitch.EqualIgnoreCase ("-STRATIFY")
)
{
stratify = true;
if (!parmValue.Empty ())
{
numOfFolds = parmValue.ToInt ();
if ((numOfFolds < 1) || (numOfFolds > 1000))
{
log.Level (-1) << "ProcessCmdLineParameter ***ERROR*** -Folds[" << numOfFolds << "] must be 1 or greater and less than 10000." << endl;
Abort (true);
validParm = false;
}
}
}
else if
(parmSwitch.EqualIgnoreCase ("-RAND") ||
parmSwitch.EqualIgnoreCase ("-RANDOM") ||
parmSwitch.EqualIgnoreCase ("-RANDOMIZE")
)
{
randomize = true;
}
else
{
validParm = PicesApplication::ProcessCmdLineParameter (parmSwitch, parmValue);
}
return validParm;
} /* ProcessCmdLineParameter */
void KKJobManager::ProcessJobXmlBlockOfText (const KKStr& startStr,
istream& i
)
{
if ((startStr.SubStrPart (0, 4) != "<KKJob ") || (startStr.LastChar () != '>'))
{
log.Level (-1) << endl
<< "KKJobManager::ProcessJobXmlBlockOfText ***ERROR*** StartStr[" << startStr << "] is not a KKJob String." << endl
<< endl;
return;
}
KKStr s = startStr.SubStrPart (5);
s.TrimLeft ();
s.ChopLastChar ();
KKStr jobTypeStr = "";
kkint32 jobId = -1;
VectorKKStr parameters = s.Split (',');
for (kkuint32 x = 0; x < parameters.size (); ++x)
{
KKStr parameterStr = parameters[x];
parameterStr.TrimLeft ();
parameterStr.TrimRight ();
KKStr fieldName = parameterStr.ExtractToken2 ("=");
fieldName.TrimLeft (); fieldName.TrimRight ();
KKStr fieldValue = parameterStr.ExtractToken2 ("=");
fieldValue.TrimLeft (); fieldValue.TrimRight ();
if (fieldName.CompareIgnoreCase ("JobType") == 0)
jobTypeStr = fieldValue;
else if (fieldName.CompareIgnoreCase ("JobId") == 0)
jobId = fieldValue.ToInt ();
}
if (jobTypeStr.Empty () || (jobId < 0))
{
log.Level (-1) << endl
<< "KKJobManager::ProcessJobXmlBlockOfText ***ERROR*** StartStr[" << startStr << "]." << endl
<< " JobType and/or JobId were not provided." << endl
<< endl;
return;
}
KKJobPtr j = jobs->LookUpByJobId (jobId);
if (j == NULL)
{
// We do not have this job in memory yet. We will have to create it now.
KKStr emptyStatusStr = "JobId\t" + StrFormatInt (jobId, "ZZZZ0");
j = KKJob::CallAppropriateConstructor (this, jobTypeStr, emptyStatusStr);
}
j->CompletedJobDataRead (i);
} /* ProcessJobXmlBlockOfText */
void KKJobManager::StatusFileProcessLine (const KKStr& ln,
istream& statusFile
)
{
if (ln.SubStrPart (0, 1) == "//")
{
// A coment line; we can ignore it.
return;
}
KKStr statusStr (ln);
KKStr fieldName = statusStr.ExtractToken2 ("\t");
if (fieldName.Empty ())
{
// A empty line we will ignore it.
return;
}
statusStr.TrimLeft ("\n\r\t ");
statusStr.TrimRight ("\n\r\t ");
if (fieldName.CompareIgnoreCase ("JOB") == 0)
{
// We have a KKJob entr line; the next field determines JobType fllowed by parameters for that JobType constructor.
KKStr jobTypeName = fieldName = statusStr.ExtractToken2 ("\t");
KKJobPtr j = KKJob::CallAppropriateConstructor (this, jobTypeName, statusStr);
KKJobPtr existingJob = jobs->LookUpByJobId (j->JobId ());
if (existingJob)
{
existingJob->ReFresh (*j);
delete j; j = NULL;
}
else
{
jobs->PushOnBack (j);
}
}
else if (fieldName.EqualIgnoreCase ("CPUTIMEUSED"))
{
double cpuTimeUsed = statusStr.ExtractTokenDouble ("\t");
cpuTimeTotalUsed += cpuTimeUsed;
}
else if (fieldName.EqualIgnoreCase ("CURRENTDATETIME"))
{
KKB::DateTime dateTime = KKB::DateTime (statusStr);
if (!dateTimeFirstOneFound)
{
dateTimeFirstOneFound = true;
dateTimeStarted = dateTime;
}
dateTimeEnded = dateTime;
}
else if (fieldName.EqualIgnoreCase ("ExpansionCount"))
expansionCount = statusStr.ToInt ();
else if (fieldName.EqualIgnoreCase ("ExpansionFirstJobId"))
expansionFirstJobId = statusStr.ToInt ();
else if (fieldName.EqualIgnoreCase ("JobStatusChange"))
StatusFileProcessLineJobStatusChange (statusStr);
else if (fieldName.EqualIgnoreCase ("NextJobId"))
nextJobId = statusStr.ExtractTokenInt ("\t");
else if (fieldName.EqualIgnoreCase ("QuitRunning"))
quitRunning = true;
else if (fieldName.EqualIgnoreCase ("Restart"))
restart = false;
else if (fieldName.EqualIgnoreCase ("Status"))
status = KKJob::JobStatusFromStr (statusStr);
else
{
log.Level (-1) << "KKJobManager::StatusFileProcessLine Invalid Field Name[" << fieldName << "]." << endl;
}
} /* StatusFileProcessLine */
void ClassificationBiasMatrix::ReadXML (istream& sr)
{
char buff[10240];
KKStr l (512);
if (sr.eof ())
return;
MLClassListPtr fileClasses = NULL;
sr.getline (buff, sizeof (buff));
while (!sr.eof ())
{
l = buff;
l.TrimRight ();
if (l.CompareIgnoreCase ("</ClassificationBiasMatrix>") == 0)
break;
KKStr lineName = l.ExtractToken2 ("\t");
if (!lineName.Empty ())
{
KKStr fieldValue = l.ExtractToken2 ("\t");
if (lineName.CompareIgnoreCase ("Classes") == 0)
{
delete fileClasses; fileClasses = NULL;
fileClasses = MLClassList::BuildListFromDelimtedStr (fieldValue, ',');
if (classes == NULL)
classes = new MLClassList (*fileClasses);
}
else if (lineName.CompareIgnoreCase ("ConfigDateTime") == 0)
{
configDateTime = fieldValue;
}
else if (lineName.CompareIgnoreCase ("ConfigFileName") == 0)
{
configFileNameFromMatrixBiasFile = fieldValue;
}
else if (lineName.CompareIgnoreCase ("ConfigFileDateTime") == 0)
{
configDateTime = fieldValue;
}
else if (lineName.CompareIgnoreCase ("DateTime") == 0)
{
dateTimeFileWritten = fieldValue;
}
else if (lineName.CompareIgnoreCase ("DateTimeFileWritten") == 0)
{
dateTimeFileWritten = fieldValue;
}
else if (lineName.CompareIgnoreCase ("FileName") == 0)
{
}
else if (lineName.CompareIgnoreCase ("NumClasses") == 0)
{
numClasses = fieldValue.ToInt ();
}
else if (lineName.CompareIgnoreCase ("<SimpleConfusionMatrix>") == 0)
{
ReadSimpleConfusionMatrix (sr, fileClasses);
}
}
if (!sr.eof ())
sr.getline (buff, sizeof (buff));
}
} /* ReadXML */
bool RandomSplits::ProcessCmdLineParameter (char parmSwitchCode,
KKStr parmSwitch,
KKStr parmValue
)
{
KKStr parmValueUpper (parmValue);
parmValueUpper.Upper ();
parmSwitch.Upper ();
if ((parmSwitch == "-CONFIGFILENAME") || (parmSwitch == "-C") || (parmSwitch == "-CONFIG"))
{
configFileName = parmValue;
}
else if ((parmSwitch == "-DATAFILE") || (parmSwitch == "-DF"))
{
dataFileName = parmValue;
}
else if ((parmSwitch == "-F") || (parmSwitch == "-FORMAT"))
{
format = FeatureFileIO::FileFormatFromStr (parmValue);
if (!format)
{
log.Level (-1) << endl << endl
<< "ProcessCmdLineParameter ***ERROR*** No such format as[" << parmValue<< "]." << endl
<< endl;
Abort (true);
}
}
else if (parmSwitch.EqualIgnoreCase ("-NumFolds") ||
parmSwitch.EqualIgnoreCase ("-NF") ||
parmSwitch.EqualIgnoreCase ("-NumOfFolds") ||
parmSwitch.EqualIgnoreCase ("-NOF")
)
{
numFolds = parmValue.ToInt ();
if ((numFolds != 0) && (numFolds < 2))
{
log.Level (-1) << endl
<< "ProcessCmdLineParameter ***ERROR*** Invalid NumFolds[" << parmValue<< "]." << endl
<< " Must be '0' or greter than '1'." << endl
<< endl;
Abort (true);
}
}
else if ((parmSwitch == "-NUMSPLITS") || (parmSwitch == "-NS") || (parmSwitch == "-SPLITS"))
{
numSplits = parmValue.ToInt ();
}
else if ((parmSwitch == "-SPLITPERCENTAGE") || (parmSwitch == "-SP"))
{
bool percentage = false;
if (parmValue.LastChar () == '%')
{
percentage = true;
parmValue.ChopLastChar ();
}
splitFraction = parmValue.ToFloat ();
if (percentage)
splitFraction = splitFraction / 100.0f;
else
{
if (splitFraction >= 1.0f)
{
log.Level (-1) << endl << endl
<< "ProcessCmdLineParameter ***ERROR*** Invalid Split Percentage[" << splitFraction << "]" << endl
<< endl
<< " If you want to enter as percentage include a '%' sign otherwise it is assumed to be a fraction." << endl
<< endl;
}
}
}
else if (parmSwitch.EqualIgnoreCase ("Restart"))
{
restart = true;
}
else
{
log.Level (-1) << endl << endl
<< "ProcessCmdLineParameter ***ERROR***" << endl
<< endl
<< " Invalid Parameter[" << parmSwitch << "]" << endl
<< endl;
Abort (true);
}
return !Abort ();
} /* ProcessCmdLineParameter */
