void MLSymbolTable::audit(void)
{
int i=0;
bool OK = true;
int size = mMap.size();
for(i=0; i<size; ++i)
{
SymbolIDT id = getID(i);
if (i != id)
{
OK = false;
break;
}
}
if (OK)
{
debug() << "Symbol table OK. " << size << " symbols.\n";
}
else
{
int idx = mIndexesByID[i];
SymbolIDT id = getID(i);
const std::string& s = getStringByID(i);
MLError() << "MLSymbolTable: error in symbol table, line " << i << ":\n";
MLError() << " ID " << i << ": index " << idx << " = " << s << ", ID = " << id << "\n";
}
}
void MLSymbolTable::dump(void)
{
bool found;
int i, idx;
int size = mMap.size();
debug() << "---------------------------------------------------------\n";
debug() << size << " symbols:\n";
// print in sorted order.
for(idx=0; idx<size; ++idx)
{
found = false;
for(i=0; i<size; ++i)
{
int idxAtI = mIndexesByID[i];
if (idx == idxAtI)
{
found = true;
break;
}
}
if (found)
{
const std::string& s = getStringByID(i);
SymbolIDT id = getID(i);
debug() << " ID " << i << ": index " << idx << " = " << s << ", ID = " << id << "\n";
}
else
{
MLError() << "error: symbol index " << idx << "not found! \n";
}
}
}
std::tuple<cv::Mat1d, double, vl_size, double, double> SGDStep::loadWithPlatt(const std::string &fileName) const
{
cv::FileStorage fs(fileName, cv::FileStorage::READ);
if ((fs["model"].isNone() || fs["model"].empty()) ||
(fs["bias"].isNone() || fs["bias"].empty()) ||
(fs["plattA"].isNone() || fs["plattA"].empty()) ||
(fs["plattB"].isNone() || fs["plattB"].empty())) {
std::stringstream s;
s << "Error. Unable to load classifier data from file: " << fileName << ". Aborting." << std::endl;
throw MLError(s.str(), currentMethod, currentLine);
}
cv::Mat1d model;
double bias;
double iterations;
double plattA;
double plattB;
fs["model"] >> model;
fs["bias"] >> bias;
fs["plattA"] >> plattA;
fs["plattB"] >> plattB;
if(fs["iterations"].isNone() || fs["iterations"].empty()) {
inform("No iteration info found, skipping. Maybe an old classifier format?");
iterations = 0;
} else {
fs["iterations"] >> iterations;
}
fs.release();
return std::make_tuple(model, bias, static_cast<vl_size>(iterations), plattA, plattB);
}
void SGDStep::save(const cv::Mat1d &model,
const double bias,
const double iterations,
const double plattA,
const double plattB) const
{
cv::Ptr<SGDConfig> config;
try {
config = config_cast<SGDConfig>(this->mConfig);
} catch(std::bad_cast) {
std::stringstream s;
s << "Wrong config type: " << this->mConfig->identifier();
throw MLError(s.str(), currentMethod, currentLine);
}
cv::FileStorage fs(config->classifierFiles()[0], cv::FileStorage::WRITE);
fs << "model" << model;
fs << "bias" << bias;
fs << "iterations" << iterations;
fs << "plattA" << plattA;
fs << "plattB" << plattB;
fs.release();
}
void MLPluginProcessor::loadPluginDescription(const char* desc)
{
mpPluginDoc = new XmlDocument(String(desc));
if (mpPluginDoc.get())
{
ScopedPointer<XmlElement> doc (mpPluginDoc->getDocumentElement(true));
if (doc) // true = quick scan header
{
mEngine.scanDoc(&*mpPluginDoc, &mNumParameters);
debug() << "loaded " << JucePlugin_Name << " plugin description, " << mNumParameters << " parameters.\n";
}
else
{
MLError() << "MLPluginProcessor: error loading plugin description!\n";
}
}
else
{
MLError() << "MLPluginProcessor: couldn't load plugin description!\n";
return;
}
// get plugin parameters and initial values and create corresponding model properties.
int params = getNumParameters();
for(int i=0; i<params; ++i)
{
MLPublishedParamPtr p = getParameterPtr(i);
MLPublishedParam* param = &(*p);
if(param)
{
MLSymbol type = param->getType();
if((type == "float") || (type == MLSymbol()))
{
debug() << param->getAlias() << " is a float type \n";
setProperty(param->getAlias(), param->getDefault());
}
else
{
debug() << param->getAlias() << " is a non-float type \n";
}
}
}
}
void MLFile::insert(const std::string& path, MLFilePtr f)
{
// debug() << "INSERTING: " << path << "\n";
int len = path.length();
if(len)
{
int b = path.find_first_of("/");
if(b == std::string::npos)
{
// leaf, insert file here creating dir if needed
// debug() << " LEAF: " << path << "\n\n" ;
// add leaf file to map
mFiles[path] = f;
}
else
{
std::string firstDir = path.substr(0, b);
std::string restOfDirs = path.substr(b + 1, len - b);
// debug() << " FIRST: " << firstDir << ", REST " << restOfDirs << "\n";
// find or add first dir
if(firstDir == "")
{
MLError() << "MLFile::insert: empty directory name!\n";
}
else
{
if(mFiles.find(firstDir) == mFiles.end())
{
mFiles[firstDir] = MLFilePtr(new MLFile(firstDir));
}
mFiles[firstDir]->insert(restOfDirs, f);
}
}
}
else
{
MLError() << "MLFile::insert: empty file name!\n";
}
}
void MLPluginProcessor::loadPluginDescription(const char* desc)
{
mpPluginDoc = new XmlDocument(String(desc));
if (mpPluginDoc.get())
{
ScopedPointer<XmlElement> doc (mpPluginDoc->getDocumentElement(true));
if (doc) // true = quick scan header
{
mEngine.scanDoc(&*mpPluginDoc, &mNumParameters);
//debug() << "loaded " << JucePlugin_Name << " plugin description, " << mNumParameters << " parameters.\n";
}
else
{
MLError() << "MLPluginProcessor: error loading plugin description!\n";
}
}
else
{
MLError() << "MLPluginProcessor: couldn't load plugin description!\n";
}
}
std::tuple<cv::Mat1d, double, vl_size, double, double> SGDStep::loadWithPlatt() const
{
cv::Ptr<SGDConfig> config;
try {
config = config_cast<SGDConfig>(this->mConfig);
} catch(std::bad_cast) {
std::stringstream s;
s << "Wrong config type: " << this->mConfig->identifier();
throw MLError(s.str(), currentMethod, currentLine);
}
return this->loadWithPlatt(config->classifierFiles()[0]);
}
// MLProc::prepareToProcess() is called after all connections in DSP graph are made.
// This is where sample rates and block sizes propagate through the graph, and
// are checked for consistency.
// Setup internal buffers and data to prepare for processing any attached input signals.
// MLProcs have no concept of enabled -- it's up to the enclosing container to disable
// itself if things go wrong here.
//
MLProc::err MLProc::prepareToProcess()
{
MLProc::err e = OK;
// debug() << "preparing " << getClassName() << " \"" << getName() << "\" : " ;
int ins = getNumInputs();
int outs = getNumOutputs();
MLSampleRate rate = getContextSampleRate();
int blockSize = getContextVectorSize();
// debug() << ins << " ins, " << outs << " outs, rate " << rate << ", blockSize " << blockSize << "\n";
// All inputs must have a signal connected.
// So connect unconnected inputs to null input signal.
for (int i=0; i<ins; i++)
{
if (!mInputs[i])
{
mInputs[i] = &getContext()->getNullInput();
}
}
// set size and rate of output signals
for (int i=1; i<=outs; ++i)
{
MLSignal& out = getOutput(i);
if (&out)
{
out.setRate(rate);
MLSample* outData = out.setDims(blockSize);
if (!outData)
{
e = memErr;
goto bail;
}
}
else
{
MLError() << "MLProc::prepareToProcess: null output " << i << " for " << getName() << "! \n";
}
//debug() << " out " << i << ": " << (void *)(MLSignal*)(&out) << ", " << out.getSize() << " samples.\n";
}
e = resize();
// recalc params for new sample rate
mParamsChanged = true;
bail:
return e;
}
void MLSymbolKey::makeString()
{
if (mLength && mpData)
{
if (mpString) delete(mpString);
mpString = new std::string(mpData, mLength);
if (!mpString)
{
MLError() << "MLSymbolKey::makeString: could not allocate!\n";
}
else
{
mpData = mpString->data();
// debug() << "made string " << *mpString << "\n";
}
}
}
void SGDStep::save(const cv::Mat1d &model,
const double bias,
const double iterations) const
{
cv::Ptr<SGDConfig> config;
try {
config = config_cast<SGDConfig>(this->mConfig);
} catch(std::bad_cast) {
std::stringstream s;
s << "Wrong config type: " << this->mConfig->identifier();
throw MLError(s.str(), currentMethod, currentLine);
}
this->save(config->classifierFiles()[0],
model,
bias,
iterations);
}
MLFilePtr MLFile::find(const std::string& path)
{
// debug() << "FINDING: " << path << "\n";
int len = path.length();
if(len)
{
int b = path.find_first_of("/");
if(b == std::string::npos)
{
// end of path, find short name here or return fail.
//debug() << " path end: " << path << "\n\n" ;
nameToFileMap::const_iterator it;
it = mFiles.find(path);
if(it != mFiles.end())
{
// return the found file.
return it->second;
}
else
{
//debug() << "MLFile::find: did not find " << path << " in :\n";
nameToFileMap::const_iterator it2;
for(it2 = mFiles.begin(); it2 != mFiles.end(); ++it2)
{
//debug() << it2->first << ", ";
}
//debug() << "\n";
return MLFilePtr();
}
}
else
{
std::string firstDir = path.substr(0, b);
std::string restOfDirs = path.substr(b + 1, len - b);
//debug() << " FIRST: " << firstDir << ", REST " << restOfDirs << "\n";
// find file matching first dir
if(firstDir == "")
{
MLError() << "MLFile::find: empty directory name!\n";
}
else if(mFiles.find(firstDir) != mFiles.end())
{
// look for rest of dirs in found non-leaf file
return mFiles[firstDir]->find(restOfDirs);
}
else
{
return MLFilePtr();
}
}
}
else
{
MLError() << "MLFile::find: empty file name!\n";
}
return MLFilePtr();
}
void MLPluginProcessor::setStateFromXML(const XmlElement& xmlState, bool setViewAttributes)
{
if (!(xmlState.hasTagName (JucePlugin_Name))) return;
if (!(mEngine.getCompileStatus() == MLProc::OK)) return; // TODO revisit need to compile first
// getCallbackLock() is in juce_AudioProcessor
// process lock is a quick fix. it is here to prevent doParams() from getting called in
// process() methods and thereby setting mParamsChanged to false before the real changes take place.
// A better alternative would be a lock-free queue of parameter changes.
const ScopedLock sl (getCallbackLock());
// only the differences between default parameters and the program state are saved in a program,
// so the first step is to set the default parameters.
setDefaultParameters();
// get program version of saved state
unsigned blobVersion = xmlState.getIntAttribute ("pluginVersion");
unsigned pluginVersion = JucePlugin_VersionCode;
if (blobVersion > pluginVersion)
{
// TODO show error to user
MLError() << "MLPluginProcessor::setStateFromXML: saved program version is newer than plugin version!\n";
return;
}
// try to load scale if a scale attribute exists
// TODO auto save all state including this
const String scaleDir = xmlState.getStringAttribute ("scaleDir"); // look for old-style dir attribute
const String scaleName = xmlState.getStringAttribute ("scaleName");
String fullName;
if(scaleName != String::empty)
{
fullName = scaleName;
if(scaleDir != String::empty)
{
fullName = scaleDir + String("/") + fullName + ".scl";
}
}
else
{
fullName = "12-equal";
}
std::string fullScaleName(fullName.toUTF8());
setProperty("key_scale", fullScaleName);
bool loaded = false;
// look for scale under full name with path
if(fullScaleName != std::string())
{
const MLFilePtr f = mScaleFiles->getFileByName(fullScaleName);
if(f != MLFilePtr())
{
loadScale(f->mFile);
loaded = true;
}
}
if(!loaded)
{
loadDefaultScale();
}
// get preset name saved in blob. when saving from AU host, name will also be set from RestoreState().
const String presetName = xmlState.getStringAttribute ("presetName");
setProperty("preset", std::string(presetName.toUTF8()));
/*
debug() << "MLPluginProcessor: setStateFromXML: loading program " << presetName << ", version " << std::hex << blobVersion << std::dec << "\n";
MemoryOutputStream myStream;
xmlState->writeToStream (myStream, "");
debug() << myStream.toString();
*/
/*
setCurrentPresetName(presetName.toUTF8());
setCurrentPresetDir(presetDir.toUTF8());
*/
// get plugin-specific translation table for updating older versions of data
std::map<MLSymbol, MLSymbol> translationTable;
// TODO move this into Aalto!
// make translation tables based on program version.
//
if (blobVersion <= 0x00010120)
{
// translate seq parameters
for(unsigned n=0; n<16; ++n)
{
std::stringstream pName;
std::stringstream pName2;
pName << "seq_value" << n;
pName2 << "seq_pulse" << n;
MLSymbol oldSym(pName.str());
MLSymbol newSym = MLSymbol("seq_value#").withFinalNumber(n);
MLSymbol oldSym2(pName2.str());
MLSymbol newSym2 = MLSymbol("seq_pulse#").withFinalNumber(n);
translationTable[oldSym] = newSym;
translationTable[oldSym2] = newSym2;
}
}
if (blobVersion <= 0x00010200)
{
MLSymbol oldSym = MLSymbol("seq_value");
MLSymbol newSym = MLSymbol("seq_value").withFinalNumber(0);
MLSymbol oldSym2 = MLSymbol("seq_pulse");
MLSymbol newSym2 = MLSymbol("seq_pulse").withFinalNumber(0);
translationTable[oldSym] = newSym;
translationTable[oldSym2] = newSym2;
// translate seq parameters
for(unsigned n=1; n<16; ++n)
{
oldSym = MLSymbol("seq_value#").withFinalNumber(n);
newSym = MLSymbol("seq_value").withFinalNumber(n);
oldSym2 = MLSymbol("seq_pulse#").withFinalNumber(n);
newSym2 = MLSymbol("seq_pulse").withFinalNumber(n);
translationTable[oldSym] = newSym;
translationTable[oldSym2] = newSym2;
}
}
// get params from xml
const unsigned numAttrs = xmlState.getNumAttributes();
String patcherInputStr ("patcher_input_");
for(unsigned i=0; i<numAttrs; ++i)
{
// get name / value pair.
const String& attrName = xmlState.getAttributeName(i);
const MLParamValue paramVal = xmlState.getDoubleAttribute(attrName);
// if not a patcher input setting,
if (!attrName.contains(patcherInputStr))
{
// see if we have this named parameter in our engine.
MLSymbol paramSym = XMLAttrToSymbol(attrName);
const int pIdx = getParameterIndex(paramSym);
if (pIdx >= 0)
{
// debug() << "setStateFromXML: <" << paramSym << " = " << paramVal << ">\n";
setPropertyImmediate(paramSym, paramVal);
}
else // try finding a match through translation table.
{
//debug() << "Looking for parameter " << paramSym << " in table...\n";
std::map<MLSymbol, MLSymbol>::iterator it;
it = translationTable.find(paramSym);
if (it != translationTable.end())
{
const MLSymbol newSym = translationTable[paramSym];
const int pNewIdx = getParameterIndex(newSym);
if (pNewIdx >= 0)
{
//debug() << "translated parameter to " << newSym << " .\n";
setPropertyImmediate(newSym, paramVal);
}
else
{
MLError() << "MLPluginProcessor::setStateFromXML: no such parameter! \n";
}
}
else
{
// fail silently on unfound params, because we have deprecated some but they may still
// be around in old presets.
//debug() << "MLPluginProcessor::setStateFromXML: parameter " << paramSym << " not found!\n";
}
}
}
}
// get editor state from XML
if(setViewAttributes)
{
int x = xmlState.getIntAttribute("editor_x");
int y = xmlState.getIntAttribute("editor_y");
int width = xmlState.getIntAttribute("editor_width");
int height = xmlState.getIntAttribute("editor_height");
mEditorRect = MLRect(x, y, width, height);
mEditorNumbersOn = xmlState.getIntAttribute("editor_num", 1);
mEditorAnimationsOn = xmlState.getIntAttribute("editor_anim", 1);
}
}
void MmaSink::checkforerror() const {
if(MLError(d_mlink)!=MLEOK) errorc(__LINE__);
};
cv::Mat SGDStep::optimizeImpl(const bool debugMode,
const std::pair<std::vector<std::vector<uint32_t>>, std::vector<std::vector<uint32_t>>> &indices,
const std::vector<std::pair<cv::Mat, int32_t>> &data) const
{
cv::Ptr<SGDConfig> config;
try {
config = config_cast<SGDConfig>(this->mConfig);
} catch(std::bad_cast) {
std::stringstream s;
s << "Wrong config type: " << this->mConfig->identifier();
throw MLError(s.str(), currentMethod, currentLine);
}
std::vector<double> lambdas = config->lambdas();
std::vector<double> learningRates = config->learningRates();
std::vector<double> multipliers = config->multipliers();
if(!checkRangeProperties<double>(lambdas) || !checkRangeProperties<double>(learningRates) || !checkRangeProperties<double>(multipliers)) {
throw MLError("Config parameters do not span a valid range.", currentMethod, currentLine);
}
double lambdaStart, lambdaEnd, lambdaInc;
lambdaStart = lambdas[0];
lambdaEnd = lambdas[1];
lambdaInc = lambdas[2];
double lrStart, lrEnd, lrInc;
lrStart = learningRates[0];
lrEnd = learningRates[1];
lrInc = learningRates[2];
double mulStart, mulEnd, mulInc;
mulStart = multipliers[0];
mulEnd = multipliers[1];
mulInc = multipliers[2];
double bestLambda = 0;
double bestLearningRate = 0;
double bestMultiplier = 0;
double bestF = 0;
std::vector<cv::Mat1d> trainingsDescriptorCache(config->folds());
std::vector<cv::Mat1d> trainingsLabelCache(config->folds());
std::vector<cv::Mat1d> testDescriptorCache(config->folds());
std::vector<cv::Mat1d> testLabelCache(config->folds());
for(double lambda = lambdaStart; lambda < lambdaEnd; lambda += lambdaInc) {
for(double lr = lrStart; lr < lrEnd; lr += lrInc) {
for(double mul = mulStart; mul < mulEnd; mul += mulInc) {
if(debugMode) {
debug("Lambda:", lambda);
debug("Learning rate:", lr);
debug("Multiplier:", mul);
}
double avgF = 0;
// Iterate over folds
for(size_t fold = 0; fold < config->folds(); ++fold) {
if(trainingsDescriptorCache[fold].empty() ||
trainingsLabelCache[fold].empty()) {
if(debugMode) { debug("Rebuilding training cache."); }
cv::Mat tmpDesc;
cv::Mat tmpIdx;
for(auto idx : indices.first[fold]) {
tmpDesc.push_back(data[idx].first);
tmpIdx.push_back(data[idx].second);
}
if(tmpDesc.type() != CV_64F) {
tmpDesc.convertTo(trainingsDescriptorCache[fold], CV_64F);
} else {
trainingsDescriptorCache[fold] = tmpDesc;
}
if(tmpIdx.type() != CV_64F) {
tmpIdx.convertTo(trainingsLabelCache[fold], CV_64F);
} else {
trainingsLabelCache[fold] = tmpIdx;
}
}
if(testDescriptorCache[fold].empty() ||
testLabelCache[fold].empty()) {
if(debugMode) { debug("Rebuilding test cache."); }
cv::Mat tmpDesc;
cv::Mat tmpIdx;
for(auto idx : indices.second[fold]) {
tmpDesc.push_back(data[idx].first);
tmpIdx.push_back(data[idx].second);
}
if(tmpDesc.type() != CV_64F) {
tmpDesc.convertTo(testDescriptorCache[fold], CV_64F);
} else {
testDescriptorCache[fold] = tmpDesc;
}
if(tmpIdx.type() != CV_64F) {
tmpIdx.convertTo(testLabelCache[fold], CV_64F);
} else {
testLabelCache[fold] = tmpIdx;
}
}
if(debugMode) { debug("Setting up SVM."); }
cv::Ptr<VlFeatWrapper::SGDSolver> solver = new VlFeatWrapper::SGDSolver(trainingsDescriptorCache[fold],
trainingsDescriptorCache[fold],
lambda);
if(debugMode) { debug("Setting parameters."); }
// Bias learning rate and multiplier
solver->setBiasLearningRate(lr);
solver->setBiasMultiplier(mul);
// Sample weights
cv::Mat1d weights = calculateWeights(trainingsLabelCache[fold]);
solver->setWeights(weights);
if(debugMode) { debug("Training..."); }
solver->train();
cv::Mat1d predictions = solver->predict(testDescriptorCache[fold]);
double negativeLabel, positiveLabel;
cv::minMaxIdx(testLabelCache[fold], &negativeLabel, &positiveLabel, NULL, NULL);
predictions.setTo(negativeLabel, predictions < 0);
predictions.setTo(positiveLabel, predictions >= 0);
predictions = predictions.t();
double f = Metrics::f1(predictions, testLabelCache[fold]);
if(debugMode) { debug("F1 score:", f); }
avgF += f;
}
avgF /= config->folds();
if(avgF > bestF) {
bestLambda = lambda;
bestLearningRate = lr;
bestMultiplier = mul;
bestF = avgF;
}
}
}
}
debug("Best F1 score:", bestF);
debug("Best lambda:", bestLambda);
debug("Best learning rate:", bestLearningRate);
debug("Best multiplier:", bestMultiplier);
config->setLambdas(std::vector<double>({bestLambda}));
config->setLearningRates(std::vector<double>({bestLearningRate}));
config->setMultipliers(std::vector<double>({bestMultiplier}));
return cv::Mat();
}
bool MmaSink::verror() const {
return MLError(d_mlink)!=MLEOK;
};
cv::Mat SGDStep::trainImpl(const bool debugMode,
const cv::Mat &input,
const cv::Mat &labels) const
{
cv::Ptr<SGDConfig> config;
try {
config = config_cast<SGDConfig>(this->mConfig);
} catch(std::bad_cast) {
std::stringstream s;
s << "Wrong config type: " << this->mConfig->identifier();
throw MLError(s.str(), currentMethod, currentLine);
}
if(input.empty()) {
throw MLError("Missing parameters, input empty.", currentMethod, currentLine);
} else if(labels.empty()) {
throw MLError("Missing parameters, labels empty.", currentMethod, currentLine);
}
cv::Mat1d dInput;
cv::Mat1d dParam;
if(!(input.type() == CV_64FC1)) {
if(debugMode) { debug("Incompatible type of input data, converting."); }
input.convertTo(dInput, CV_64FC1);
} else {
dInput = input;
}
if(!(labels.type() == CV_64FC1)) {
if(debugMode) { debug("Incompatible type of parameter data, converting."); }
labels.convertTo(dParam, CV_64FC1);
} else {
dParam = labels;
}
cv::Mat1d weights = calculateWeights(labels);
double lambda = config->lambdas()[0];
if(debugMode) { debug("Lambda:", lambda); }
double learningRate = config->learningRates()[0];
if(debugMode) { debug("Learning rate:", learningRate); }
double epsilon = config->epsilon();
if(debugMode) { debug("Epsilon:", epsilon); }
double multiplier = config->multipliers()[0];
if(debugMode) { debug("Multiplier:", multiplier); }
vl_size iterations = config->iterations();
if(debugMode) { debug("Iterations:", iterations); }
vl_size maxIterations = config->maxIterations();
if(debugMode) { debug("Max. iterations:", maxIterations); }
cv::Ptr<VlFeatWrapper::SGDSolver> solver = new VlFeatWrapper::SGDSolver(dInput,
dParam,
lambda);
// Bias learning rate and multiplier
if(learningRate > 0) { solver->setBiasLearningRate(learningRate); }
if(multiplier > 0) { solver->setBiasMultiplier(multiplier); }
// Sample weights
if(!weights.empty()) { solver->setWeights(weights); }
try {
std::tuple<cv::Mat1d, double, vl_size> warmStartData = this->load(config->classifierFiles()[0]);
if(!std::get<0>(warmStartData).empty()) {
solver->setModel(std::get<0>(warmStartData));
}
solver->setBias(std::get<1>(warmStartData));
solver->setStartIterationCount(std::get<2>(warmStartData));
if(debugMode) { debug("Warm starting training."); }
} catch(MLError & e) {
if(debugMode) { debug("Starting training."); }
}
solver->train();
cv::Mat1d model;
double bias = 0;
//Updated classifier data
model = solver->getModelMat();
if(debugMode) { debug("Model size:", model.size()); }
bias = solver->getBias();
if(debugMode) { debug("Bias:", bias); }
iterations = solver->getIterationCount();
if(debugMode) { debug("Iterations:", iterations); }
cv::Mat1d predictions = solver->predict(dInput);
double negativeLabel, positiveLabel;
cv::minMaxIdx(dParam, &negativeLabel, &positiveLabel, NULL, NULL);
predictions.setTo(negativeLabel, predictions < 0);
predictions.setTo(positiveLabel, predictions >= 0);
predictions = predictions.t();
if(config->plattScale()) {
std::pair<double, double> plattParams = Platt::platt_calibrate(predictions, dParam);
if(debugMode) { debug("Platt parameter A:", plattParams.first); }
if(debugMode) { debug("Platt parameter B:", plattParams.second); }
if(!model.empty()) {
this->save(model,
bias,
iterations,
plattParams.first,
plattParams.second);
}
}
if(!model.empty()) {
this->save(model,
bias,
iterations);
}
return cv::Mat();
}
cv::Mat SGDStep::predictImpl(const bool debugMode,
const cv::Mat &input) const
{
cv::Ptr<SGDConfig> config;
try {
config = config_cast<SGDConfig>(this->mConfig);
} catch(std::bad_cast) {
std::stringstream s;
s << "Wrong config type: " << this->mConfig->identifier();
throw MLError(s.str(), currentMethod, currentLine);
}
std::vector<std::string> classifiers = config->classifierFiles();
if(debugMode) { debug(classifiers.size(), "classifier(s)"); }
cv::Mat1d results(1, classifiers.size());
for(size_t idx = 0; idx < classifiers.size(); ++idx) {
std::string classifierFile = classifiers[idx];
if(debugMode) { debug("Loading classifier", classifierFile); }
std::tuple<cv::Mat1d, double, vl_size> classifierData;
std::tuple<cv::Mat1d, double, vl_size, double, double> plattClassifierData;
try {
if(config->plattScale()) {
plattClassifierData = this->loadWithPlatt(classifierFile);
} else {
classifierData = this->load(classifierFile);
}
if(input.cols != std::get<0>(classifierData).cols) {
std::stringstream s;
s << "Data doesn't fit trained model." << std::endl;
throw MLError(s.str(), currentMethod, currentLine);
} else {
if(input.type() != CV_64F) {
cv::Mat tmp;
input.convertTo(tmp, CV_64F);
if(config->plattScale()) {
double score = tmp.dot(std::get<0>(classifierData)) + std::get<1>(classifierData);
results.at<double>(idx) = Platt::sigmoid_predict(score,
std::get<3>(plattClassifierData),
std::get<4>(plattClassifierData));
} else {
double score = tmp.dot(std::get<0>(classifierData)) + std::get<1>(classifierData);
results.at<double>(idx) = score;
}
} else {
if(config->plattScale()) {
double score = input.dot(std::get<0>(classifierData)) + std::get<1>(classifierData);
results.at<double>(idx) = Platt::sigmoid_predict(score,
std::get<3>(plattClassifierData),
std::get<4>(plattClassifierData));
} else {
double score = input.dot(std::get<0>(classifierData)) + std::get<1>(classifierData);
results.at<double>(idx) = score;
}
}
}
} catch(MLError) {
throw;
}
}
if(config->binary()) {
if(config->plattScale()) {
double min, max;
cv::Point minIdx, maxIdx;
cv::minMaxLoc(results, &min, &max, &minIdx, &maxIdx);
int32_t best = maxIdx.x;
results.setTo(0);
results.at<double>(best) = 1;
} else {
results.setTo(1, results > 0);
results.setTo(-1, results < 0);
}
}
return results;
}
void MLProc::printErr(MLProc::err e)
{
MLError() << "*** proc " << getName() << " error: ";
switch(e)
{
case memErr:
MLError() << "memErr\n";
break;
case inputBoundsErr:
MLError() << "inputBoundsErr\n";
break;
case inputOccupiedErr:
MLError() << "inputOccupiedErr\n";
break;
case inputRateErr:
MLError() << "inputRateErr\n";
break;
case noInputErr:
MLError() << "noInputErr\n";
break;
case inputMismatchErr:
MLError() << "inputMismatchErr\n";
break;
case fractionalBlockSizeErr:
MLError() << "fractionalBlockSizeErr\n";
break;
case connectScopeErr:
MLError() << "connectScopeErr\n";
break;
case nameInUseErr:
MLError() << "nameInUseErr\n";
break;
case headNotContainerErr:
MLError() << "headNotContainerErr\n";
break;
case nameNotFoundErr:
MLError() << "nameNotFoundErr\n";
break;
case fileOpenErr:
MLError() << "fileOpenErr\n";
break;
case docSyntaxErr:
MLError() << "docSyntaxErr\n";
break;
case newProcErr:
MLError() << "newProcErr\n";
break;
case SSE2RequiredErr:
MLError() << "SSE2RequiredErr\n";
break;
case OK:
MLError() << "OK\n";
break;
default:
MLError() << "unknown error " << e << "\n";
break;
}
}
// look up a symbol by name and return its ID.
// if the symbol already exists, this routine must not allocate any memory.
SymbolIDT MLSymbolTable::getSymbolID(const char * sym, const int len)
{
SymbolIDT r = 0;
bool found = false;
int size = mMap.size();
//debug() << size << " entries, making symbol " << sym << "\n";
if (len == 0)
{
return 0;
}
// symbol data stays external for now, no memory is allocated.
MLSymbolKey symKey(sym, len);
MLSymbolMapT::iterator mapIter(mMap.find(symKey));
if (mapIter != mMap.end())
{
found = true;
r = mapIter->second;
}
if (!found)
{
// make a new entry in the symbol table.
if(size < kTableSize)
{
MLSymbolMapT::iterator beginIter;
MLSymbolMapT::iterator newEntryIter;
std::pair<MLSymbolMapT::iterator, bool> newEntryRet;
// insert key/ID pair into map, with ID=0 for now
std::pair<MLSymbolKey, SymbolIDT> newEntry(symKey, 0);
newEntryRet = mMap.insert(newEntry);
// check insertion
if (!newEntryRet.second)
{
MLError() << "MLSymbolTable::getSymbolID: error, key " << sym << " already in map!\n";
}
newEntryIter = newEntryRet.first;
beginIter = mMap.begin();
// get index of new entry
int newIndex = distance(beginIter, newEntryIter);
//debug() << "adding symbol " << sym << ", length " << len << "\n";
//debug() << "new map entry index: " << newIndex << " ID = " << size << "\n";
// make key data local in map
MLSymbolKey& newKey = const_cast<MLSymbolKey&>(newEntryIter->first);
newKey.makeString();
// set ID of new entry
newEntryIter->second = size;
// adjust indexes to reflect insertion
for(int id=0; id<size; ++id)
{
if (mIndexesByID[id] >= newIndex)
{
mIndexesByID[id]++;
}
}
// make new index list entry
mIndexesByID[size] = newIndex;
// make new string pointer.
mStringsByID[size] = newKey.mpString;
r = size;
}
else
{
debug() << "symbol table size exceeded!\n";
}
}
return r;
}