public void Train(bool enableCamera = true, bool enableSecondary = false, bool forceCompleteRetraining = true)
{
bool coarseNeedsRetraining = false;
foreach (string key in needsRetraining.Keys)
{
if (needsRetraining[key])
{
coarseNeedsRetraining = true;
}
}
if (forceCompleteRetraining || coarseNeedsRetraining)
{
int numTrainingSamples = 0;
if (enableCamera)
{
groupClassifier = new Classifier(Classifier.ClassifierType.SVM, Classifier.KernelType.Chi2);
}
if (enableSecondary)
{
groupClassifierSecondary = new Classifier(Classifier.ClassifierType.SVM, Classifier.KernelType.Chi2);
}
foreach (string region in samples.Keys)
{
if (!coarseLocations.ContainsKey(region))
{
continue;
}
string group = coarseLocations[region];
foreach (ImageTemplate template in samples[region])
{
numTrainingSamples++;
if (enableCamera)
{
groupClassifier.AddExample(group, template.TextureMatrixRow);
}
if (enableSecondary)
{
groupClassifierSecondary.AddExample(group, template.SecondaryFeaturesMatrixRow);
}
}
}
if (enableCamera)
{
groupClassifier.Train();
}
if (enableSecondary)
{
groupClassifierSecondary.Train();
}
// Train sensor fusion classifier
if (enableCamera && enableSecondary)
{
//int numClasses = samples.Keys.Count;
//float[] w = new float[numClasses];
//for (int i = 0; i < numClasses; i++) w[i] = 0.0f;
//int numMisclassifications = 0;
sensorFusionClassifier = new Classifier(Classifier.ClassifierType.NeuralNet);
foreach (string region in samples.Keys)
{
if (!coarseLocations.ContainsKey(region))
{
continue;
}
string group = coarseLocations[region];
foreach (ImageTemplate template in samples[region])
{
Dictionary <string, float> textureProbabilities, secondaryProbabilities;
groupClassifier.Predict(template.TextureMatrixRow, out textureProbabilities);
groupClassifierSecondary.Predict(template.SecondaryFeaturesMatrixRow, out secondaryProbabilities);
float[] input = new float[textureProbabilities.Keys.Count + secondaryProbabilities.Keys.Count];
int j = 0;
foreach (string key in textureProbabilities.Keys)
{
input[j++] = textureProbabilities[key];
}
foreach (string key in secondaryProbabilities.Keys)
{
input[j++] = secondaryProbabilities[key];
}
sensorFusionClassifier.AddExample(group, input);
}
}
sensorFusionClassifier.Train();
}
}
//if (enableCamera)
//{
// trainInfoByGroup.Clear();
// bfClassifierByGroup.Clear();
// classifierByGroup.Clear();
//}
//if (enableSecondary)
//{
// secondaryClassifierByGroup.Clear();
// sensorFusionClassifierByGroup.Clear();
//}
foreach (string groupName in groups.Keys)
{
//if (groups[groupName].Count == 1) continue;
if (!forceCompleteRetraining && !needsRetraining[groupName])
{
continue;
}
if (enableCamera)
{
trainInfoByGroup.Remove(groupName);
bfClassifierByGroup.Remove(groupName);
classifierByGroup.Remove(groupName);
}
if (enableSecondary)
{
secondaryClassifierByGroup.Remove(groupName);
sensorFusionClassifierByGroup.Remove(groupName);
}
List <Tuple <string, int> > trainInfo = new List <Tuple <string, int> >();
Classifier bfClassifier = new Classifier(Classifier.ClassifierType.BruteForce);
Classifier classifier = new Classifier(Classifier.ClassifierType.SVM, Classifier.KernelType.Chi2);
Classifier secondaryClassifier = new Classifier(Classifier.ClassifierType.SVM, Classifier.KernelType.Chi2);
foreach (string region in groups[groupName])
{
if (!coarseLocations.ContainsKey(region))
{
continue;
}
for (int i = 0; i < samples[region].Count; i++)
{
ImageTemplate template = samples[region][i];
Matrix <float> features = template.TextureMatrixRow;
Matrix <float> secondaryFeatures = template.SecondaryFeaturesMatrixRow;
if (enableCamera)
{
bfClassifier.AddExample(region, features);
}
if (enableCamera)
{
classifier.AddExample(region, features);
}
if (enableSecondary)
{
secondaryClassifier.AddExample(region, secondaryFeatures);
}
if (enableCamera)
{
trainInfo.Add(new Tuple <string, int>(region, i));
}
}
}
if (enableCamera)
{
bfClassifier.Train();
}
if (enableCamera)
{
classifier.Train();
}
if (enableSecondary)
{
secondaryClassifier.Train();
}
if (enableCamera)
{
trainInfoByGroup.Add(groupName, trainInfo);
}
if (enableCamera)
{
bfClassifierByGroup.Add(groupName, bfClassifier);
}
if (enableCamera)
{
classifierByGroup.Add(groupName, classifier);
}
if (enableSecondary)
{
secondaryClassifierByGroup.Add(groupName, secondaryClassifier);
}
}
if (enableCamera && enableSecondary)
{
//sensorFusionClassifierByGroup.Clear();
foreach (string groupName in groups.Keys)
{
if (!forceCompleteRetraining && !needsRetraining[groupName])
{
continue;
}
sensorFusionClassifierByGroup.Remove(groupName);
if (groups[groupName].Count == 1)
{
continue;
}
Classifier classifier = new Classifier(Classifier.ClassifierType.NeuralNet);
foreach (string region in groups[groupName])
{
if (!coarseLocations.ContainsKey(region))
{
continue;
}
for (int i = 0; i < samples[region].Count; i++)
{
ImageTemplate template = samples[region][i];
Dictionary <string, float> textureProbabilities, secondaryProbabilities;
classifierByGroup[groupName].Predict(template.TextureMatrixRow, out textureProbabilities);
secondaryClassifierByGroup[groupName].Predict(template.SecondaryFeaturesMatrixRow, out secondaryProbabilities);
float[] input = new float[textureProbabilities.Keys.Count + secondaryProbabilities.Keys.Count];
int j = 0;
foreach (string key in textureProbabilities.Keys)
{
input[j++] = textureProbabilities[key];
}
foreach (string key in secondaryProbabilities.Keys)
{
input[j++] = secondaryProbabilities[key];
}
classifier.AddExample(region, input);
}
}
classifier.Train();
sensorFusionClassifierByGroup.Add(groupName, classifier);
}
}
}