public BPM(
string[] labels,
double sparsityApproxThresh)
{
Debug.Assert(labels != null, "The labels must not be null.");
Debug.Assert(labels.Length == 2, "The labels must have two possible values.");
Debug.Assert(sparsityApproxThresh >= 0, "The sparsityApproxThresh must be greater than or equal to zero.");
// Initialise the validations
_validate = new Validate();
// Initialise the BPM
_engine = new Dictionary <DistributionType, InferenceEngine>();
_w = new Dictionary <DistributionType, Variable <Vector> >();
_w[DistributionType.Prior] = null;
_w[DistributionType.Posterior] = null;
_d = new Dictionary <DistributionType, DistributionName>();
_yPredicDistrib = Enumerable.Empty <IDictionary <string, double> >();
_yPredicLabel = new string[] { };
_mapping = new GenericClassifierMapping(labels);
// TO DO
// Evaluator mapping
var evaluatorMapping = _mapping.ForEvaluation();
_evaluator = new ClassifierEvaluator
<IList <Vector>, int, IList <string>, string>(evaluatorMapping);
// Other initialisations
_availableDatasetName = new DatasetName();
_numObservations = 0;
_numFeatures = 0;
}
public BPMMapped(
string[] labels)
{
Debug.Assert(labels != null, "The labels must not be null.");
Debug.Assert(labels.Length == 2, "The labels must have two possible values.");
// Initialise the validations
_validate = new Validate();
// Create a BPM from the mapping
_mapping = new GenericClassifierMapping(labels);
_classifier = BayesPointMachineClassifier.CreateBinaryClassifier(_mapping);
// Evaluator mapping
var evaluatorMapping = _mapping.ForEvaluation();
_evaluator = new ClassifierEvaluator
<IList <Vector>, int, IList <string>, string>(evaluatorMapping);
// Other initialisations
_availableDatasetName = new DatasetName();
_numObservations = 0;
_numFeatures = 0;
}
/// <summary>
/// CrossValidate diagnosis
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="mapping"></param>
/// <param name="reportFileName"></param>
/// <param name="crossValidationFoldCount"></param>
/// <param name="iterationCount"></param>
/// <param name="computeModelEvidence"></param>
/// <param name="batchCount"></param>
/// <remarks>Adapted from MicrosoftResearch.Infer.Learners</remarks>
public CrossValidateMapped(
Vector[] x,
IList <string> y,
GenericClassifierMapping mapping,
string reportFileName,
int crossValidationFoldCount, //folds
int iterationCount,
bool computeModelEvidence,
int batchCount)
{
Debug.Assert(x != null, "The feature vector must not be null.");
Debug.Assert(y != null, "The targe variable must not be null.");
Debug.Assert(mapping != null, "The classifier map must not be null.");
Debug.Assert(!string.IsNullOrEmpty(reportFileName), "The report file name must not be null/empty.");
Debug.Assert(iterationCount > 0, "The iteration count must be greater than zero.");
Debug.Assert(batchCount > 0, "The batch count must be greater than zero.");
// Shuffle dataset
shuffleVector(x);
// Create evaluator
var evaluatorMapping = mapping.ForEvaluation();
var evaluator = new ClassifierEvaluator <
IList <Vector>, // the type of the instance source,
int, // the type of an instance
IList <string>, // the type of the label source
string>( // the type of a label.
evaluatorMapping);
// Create performance metrics
var accuracy = new List <double>();
var negativeLogProbability = new List <double>();
var auc = new List <double>();
var evidence = new List <double>();
var iterationCounts = new List <double>();
var trainingTime = new List <double>();
// Run cross-validation
int validationSetSize = x.Length / crossValidationFoldCount;
int trainingSetSize = x.Length - validationSetSize;
int validationFoldSetSize = 0;
int trainingFoldSetSize = 0;
Console.WriteLine(
"Running {0}-fold cross-validation", crossValidationFoldCount);
if (validationSetSize == 0 || trainingSetSize == 0)
{
Console.WriteLine("Invalid number of folds");
Console.ReadKey();
System.Environment.Exit(1);
}
for (int fold = 0; fold < crossValidationFoldCount; fold++)
{
// Construct training and validation sets for fold
int validationSetStart = fold * validationSetSize;
int validationSetEnd = (fold + 1 == crossValidationFoldCount)
? x.Length
: (fold + 1) * validationSetSize;
validationFoldSetSize = validationSetEnd - validationSetStart;
trainingFoldSetSize = x.Length - validationFoldSetSize;
Vector[] trainingSet = new Vector[trainingFoldSetSize];
Vector[] validationSet = new Vector[validationFoldSetSize];
IList <string> trainingSetLabels = new List <string>();
IList <string> validationSetLabels = new List <string>();
for (int instance = 0, iv = 0, it = 0; instance < x.Length; instance++)
{
if (validationSetStart <= instance && instance < validationSetEnd)
{
validationSet[iv++] = x[instance];
validationSetLabels.Add(y[instance]);
}
else
{
trainingSet[it++] = x[instance];
trainingSetLabels.Add(y[instance]);
}
}
// Print info
Console.WriteLine(" Fold {0} [validation set instances {1} - {2}]", fold + 1, validationSetStart, validationSetEnd - 1);
// Create classifier
var classifier = BayesPointMachineClassifier.CreateBinaryClassifier(mapping);
classifier.Settings.Training.IterationCount = iterationCount;
classifier.Settings.Training.BatchCount = batchCount;
classifier.Settings.Training.ComputeModelEvidence = computeModelEvidence;
int currentIterationCount = 0;
classifier.IterationChanged += (sender, eventArgs) => { currentIterationCount = eventArgs.CompletedIterationCount; };
// Train classifier
var stopWatch = new Stopwatch();
stopWatch.Start();
classifier.Train(trainingSet, trainingSetLabels);
stopWatch.Stop();
// Produce predictions
IEnumerable <IDictionary <string, double> > predictions =
classifier.PredictDistribution(validationSet);
var predictedLabels = classifier.Predict(validationSet);
// Iteration count
iterationCounts.Add(currentIterationCount);
// Training time
trainingTime.Add(stopWatch.ElapsedMilliseconds);
// Compute accuracy
accuracy.Add(1 - (evaluator.Evaluate(validationSet, validationSetLabels, predictedLabels, Metrics.ZeroOneError) / predictions.Count()));
// Compute mean negative log probability
negativeLogProbability.Add(evaluator.Evaluate(validationSet, validationSetLabels, predictions, Metrics.NegativeLogProbability) / predictions.Count());
// Compute M-measure (averaged pairwise AUC)
auc.Add(evaluator.AreaUnderRocCurve(validationSet, validationSetLabels, predictions));
// Compute log evidence if desired
evidence.Add(computeModelEvidence ? classifier.LogModelEvidence : double.NaN);
// Persist performance metrics
Console.WriteLine(
" Accuracy = {0,5:0.0000} NegLogProb = {1,5:0.0000} AUC = {2,5:0.0000}{3} Iterations = {4} Training time = {5}",
accuracy[fold],
negativeLogProbability[fold],
auc[fold],
computeModelEvidence ? string.Format(" Log evidence = {0,5:0.0000}", evidence[fold]) : string.Empty,
iterationCounts[fold],
FormatElapsedTime(trainingTime[fold]));
SavePerformanceMetrics(
reportFileName, accuracy, negativeLogProbability, auc, evidence, iterationCounts, trainingTime);
}
}