public ValidationEngine(int id, NeuralNetwork neuralNetwork, List <string> listOfInputAttributes, string outputAttribute, float predictionThreshold, float positivePredictionLimit, float negativePredictionLimit)
{
ID = id;
_NeuralNetwork = neuralNetwork;
_ListOfInputAttributes = listOfInputAttributes;
_OutputAttribute = outputAttribute;
_RuntimeEngine = new RuntimeEngine(1, neuralNetwork, listOfInputAttributes);
_MCCCalculator = new MatthewsCorrelationCoefficientCalculator(predictionThreshold, positivePredictionLimit, negativePredictionLimit);
}
public TraintimeEngine(int id, NeuralNetwork nn, List <string> listOfInputAttributes, string outputAttribute, float momentum, float predictionThreshold, float positivePredictionLimit, float negativePredictionLimit)
{
_RuntimeEngine = new RuntimeEngine(id, nn, listOfInputAttributes);
_ListOfInputAttributes = listOfInputAttributes;
_OutputAttribute = outputAttribute;
_NeuralNetwork = nn;
_NeuronErrorDictionary = new Dictionary <int, float>();
foreach (Neuron neuron in _NeuralNetwork._ListOfNeurons)
{
_NeuronErrorDictionary.Add(neuron.ID, 0.00f);
}
_MCCCalculator = new MatthewsCorrelationCoefficientCalculator(predictionThreshold, positivePredictionLimit, negativePredictionLimit);
_Momentum = momentum;
_PreviousWeightDictionary = new Dictionary <int, float>();
foreach (SynapticConnection synaptic in _NeuralNetwork._ListOfSynapticConnections)
{
_PreviousWeightDictionary.Add(synaptic.ID, 0.00f);
}
}
protected void CalculateClassificationResults()
{
double[] estimatedTrainingClassValues = EstimatedTrainingClassValues.ToArray(); // cache values
double[] originalTrainingClassValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices).ToArray();
double[] estimatedTestClassValues = EstimatedTestClassValues.ToArray(); // cache values
double[] originalTestClassValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndices).ToArray();
var positiveClassName = ProblemData.PositiveClass;
double positiveClassValue = ProblemData.GetClassValue(positiveClassName);
ClassificationPerformanceMeasuresCalculator trainingPerformanceCalculator = new ClassificationPerformanceMeasuresCalculator(positiveClassName, positiveClassValue);
ClassificationPerformanceMeasuresCalculator testPerformanceCalculator = new ClassificationPerformanceMeasuresCalculator(positiveClassName, positiveClassValue);
OnlineCalculatorError errorState;
double trainingAccuracy = OnlineAccuracyCalculator.Calculate(originalTrainingClassValues, estimatedTrainingClassValues, out errorState);
if (errorState != OnlineCalculatorError.None)
{
trainingAccuracy = double.NaN;
}
double testAccuracy = OnlineAccuracyCalculator.Calculate(originalTestClassValues, estimatedTestClassValues, out errorState);
if (errorState != OnlineCalculatorError.None)
{
testAccuracy = double.NaN;
}
TrainingAccuracy = trainingAccuracy;
TestAccuracy = testAccuracy;
double trainingNormalizedGini = NormalizedGiniCalculator.Calculate(originalTrainingClassValues, estimatedTrainingClassValues, out errorState);
if (errorState != OnlineCalculatorError.None)
{
trainingNormalizedGini = double.NaN;
}
double testNormalizedGini = NormalizedGiniCalculator.Calculate(originalTestClassValues, estimatedTestClassValues, out errorState);
if (errorState != OnlineCalculatorError.None)
{
testNormalizedGini = double.NaN;
}
TrainingNormalizedGiniCoefficient = trainingNormalizedGini;
TestNormalizedGiniCoefficient = testNormalizedGini;
ClassificationPerformanceMeasures.Reset();
trainingPerformanceCalculator.Calculate(originalTrainingClassValues, estimatedTrainingClassValues);
if (trainingPerformanceCalculator.ErrorState == OnlineCalculatorError.None)
{
ClassificationPerformanceMeasures.SetTrainingResults(trainingPerformanceCalculator);
}
testPerformanceCalculator.Calculate(originalTestClassValues, estimatedTestClassValues);
if (testPerformanceCalculator.ErrorState == OnlineCalculatorError.None)
{
ClassificationPerformanceMeasures.SetTestResults(testPerformanceCalculator);
}
if (ProblemData.Classes == 2)
{
var f1Training = FOneScoreCalculator.Calculate(originalTrainingClassValues, estimatedTrainingClassValues, out errorState);
if (errorState == OnlineCalculatorError.None)
{
ClassificationPerformanceMeasures.TrainingF1Score = f1Training;
}
var f1Test = FOneScoreCalculator.Calculate(originalTestClassValues, estimatedTestClassValues, out errorState);
if (errorState == OnlineCalculatorError.None)
{
ClassificationPerformanceMeasures.TestF1Score = f1Test;
}
}
var mccTraining = MatthewsCorrelationCoefficientCalculator.Calculate(originalTrainingClassValues, estimatedTrainingClassValues, out errorState);
if (errorState == OnlineCalculatorError.None)
{
ClassificationPerformanceMeasures.TrainingMatthewsCorrelation = mccTraining;
}
var mccTest = MatthewsCorrelationCoefficientCalculator.Calculate(originalTestClassValues, estimatedTestClassValues, out errorState);
if (errorState == OnlineCalculatorError.None)
{
ClassificationPerformanceMeasures.TestMatthewsCorrelation = mccTest;
}
}
private void UpdateDataGridView()
{
if (InvokeRequired)
{
Invoke((Action)UpdateDataGridView);
}
else
{
if (Content == null)
{
dataGridView.Rows.Clear();
dataGridView.Columns.Clear();
solutions = null;
}
else
{
IClassificationProblemData problemData = Content.ProblemData;
var dataset = problemData.Dataset;
solutions = new List <IClassificationSolution>()
{
Content
};
solutions.AddRange(GenerateClassificationSolutions(problemData));
dataGridView.ColumnCount = 4;
dataGridView.RowCount = solutions.Count();
dataGridView.Columns[0].HeaderText = "Accuracy (training)";
dataGridView.Columns[1].HeaderText = "Accuracy (test)";
dataGridView.Columns[2].HeaderText = "Matthews Correlation Coefficient (training)";
dataGridView.Columns[3].HeaderText = "Matthews Correlation Coefficient (test)";
if (problemData.Classes == 2)
{
dataGridView.ColumnCount = 6;
dataGridView.Columns[4].HeaderText = "F1 Score (training)";
dataGridView.Columns[5].HeaderText = "F1 Score (test)";
}
for (int row = 0; row < solutions.Count; row++)
{
var solution = solutions[row];
dataGridView.Rows[row].HeaderCell.Value = solution.Name;
dataGridView[0, row].Value = solution.TrainingAccuracy;
dataGridView[1, row].Value = solution.TestAccuracy;
var trainingIndizes = problemData.TrainingIndices;
var originalTrainingValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, trainingIndizes);
var estimatedTrainingValues = solution.Model.GetEstimatedClassValues(dataset, trainingIndizes);
var testIndices = problemData.TestIndices;
var originalTestValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, testIndices);
var estimatedTestValues = solution.Model.GetEstimatedClassValues(dataset, testIndices);
OnlineCalculatorError errorState;
dataGridView[2, row].Value = MatthewsCorrelationCoefficientCalculator.Calculate(originalTrainingValues, estimatedTrainingValues, out errorState);
dataGridView[3, row].Value = MatthewsCorrelationCoefficientCalculator.Calculate(originalTestValues, estimatedTestValues, out errorState);
if (problemData.Classes == 2)
{
dataGridView[4, row].Value = FOneScoreCalculator.Calculate(originalTrainingValues, estimatedTrainingValues, out errorState);
dataGridView[5, row].Value = FOneScoreCalculator.Calculate(originalTestValues, estimatedTestValues, out errorState);
}
}
dataGridView.AutoResizeColumns(DataGridViewAutoSizeColumnsMode.ColumnHeader);
dataGridView.AutoResizeRowHeadersWidth(DataGridViewRowHeadersWidthSizeMode.AutoSizeToAllHeaders);
}
}
}
