/// <summary>
/// The main training routine
/// train a back-prop style NN classifier using learning rate and momentum
/// weight decay reduces the magnitude of a weight value over time unless that value
/// is constantly increased
/// </summary>
/// <param name="trainData"></param>
/// <param name="testdata"></param>
/// <param name="maxEpochs"></param>
/// <param name="learnRate"></param>
public void train(double[][] trainData, double[][] testData, int maxEpochs, double learnRate, string logFileName)
{
GraphData = new MatrixData(maxEpochs, 3);
GraphData.ChangeHeader(0, "Epoch");
GraphData.ChangeHeader(1, "Train Accuracy");
GraphData.ChangeHeader(2, "Test Accuracy");
// train a back-prop style NN classifier using learning rate and momentum
// weight decay reduces the magnitude of a weight value over time unless that value
// is constantly increased
int epoch = 0;
double[] xValues = new double[numInput]; // inputs
double[] tValues = new double[numOutput]; // target values
int[] sequence = new int[trainData.Length];
for (int i = 0; i < sequence.Length; i++)
{
sequence[i] = i;
}
using (StreamWriter writer = File.AppendText(logFileName))
{
while (epoch < maxEpochs)
{
//double mse = MeanSquaredError(trainData);
//if (mse < 0.020) break; // consider passing value in as parameter
Shuffle(sequence); // visit each training data in random order
for (int i = 0; i < trainData.Length; i++)
{
int idx = sequence[i];
Array.Copy(trainData[idx], xValues, numInput);
Array.Copy(trainData[idx], numInput, tValues, 0, numOutput);
ComputeOutputs(xValues); // copy xValues in, compute outputs (store them internally)
UpdateWeights(tValues, learnRate); // find better weights
} // each training tuple
double trainAccuracy = Accuracy(trainData, "") * 100; // *100 to convert to percent
double testAccuracy = Accuracy(testData, "") * 100;
double trainMse = MeanSquaredError(trainData);
double testMse = MeanSquaredError(testData);
string linez = epoch.ToString() + " ";
linez = linez + trainMse.ToString() + " " + testMse.ToString() + " ";
linez = linez + trainAccuracy.ToString("F2") + "% " + testAccuracy.ToString("F2") + "% ";
linez = linez + Environment.NewLine;
writer.Write(linez);
GraphData[epoch, 0] = epoch;
GraphData[epoch, 1] = trainAccuracy;
GraphData[epoch, 2] = testAccuracy;
epoch++;
}
}
} // Train
public MatrixData GetRightOrWrongMatrix(MatrixData input)
{
MatrixData output = new MatrixData(input.NumberOfRows, 4);
output.ChangeHeader(0, "#");
output.ChangeHeader(1, "Actual");
output.ChangeHeader(2, "Predict");
output.ChangeHeader(3, "Correct?");
double[][] dataSet = input.Data.ToJagged().ToDoubleArray();
// percentage correct using winner-takes all
bool result;
int numCorrect = 0;
int numWrong = 0;
double[] xValues = new double[numInput]; // inputs
double[] tValues = new double[numOutput]; // targets
double[] yValues; // computed Y
confusionMatrix = new int[numOutput, numOutput];
//confusionMatrixCnt = 0;
for (int i = 0; i < dataSet.Length; ++i)
{
Array.Copy(dataSet[i], xValues, numInput); // parse test data into x-values and t-values
Array.Copy(dataSet[i], numInput, tValues, 0, numOutput);
yValues = this.ComputeOutputs(xValues);
int maxIndexOut = MaxIndex(yValues); // which cell in yValues has largest value?
int maxIndexExpected = MaxIndex(tValues); // which cell in yValues has largest value?
if (maxIndexOut == maxIndexExpected)
{
numCorrect++; result = true;
}
else
{
numWrong++; result = false;
}
output.SetValue(i, 0, input.GetRowName(i));
output.SetValue(i, 1, maxIndexOut);
output.SetValue(i, 2, maxIndexExpected);
output.SetValue(i, 3, (result)? "Y":"N");
}
return(output);
}
public string Task3RightWrong()
{
nn.rightOrWrong(_validationData, "valResult.txt");
_rightWrongData = nn.GetRightOrWrongMatrix(_validationData);
MatrixData trainWrongData = nn.GetRightOrWrongMatrix(_trainingData);
int rows = _rightWrongData.CountIf(3, MatrixDataExtension.StringEquals, "N") + trainWrongData.CountIf(3, MatrixDataExtension.StringEquals, "N");
_wrongData = new MatrixData(rows, trainWrongData.NumberOfColumns);
int wrongDataCounter = 0;
for (int r = 0; r < _rightWrongData.NumberOfRows; r++)
{
if (_rightWrongData[r, 3] == "N")
{
_wrongData.SetValue(wrongDataCounter, 0, _rightWrongData[r, 0]);
_wrongData.SetValue(wrongDataCounter, 1, _rightWrongData[r, 1]);
_wrongData.SetValue(wrongDataCounter, 2, _rightWrongData[r, 2]);
_wrongData.SetValue(wrongDataCounter, 3, _rightWrongData[r, 3]);
wrongDataCounter++;
}
}
for (int r = 0; r < trainWrongData.NumberOfRows; r++)
{
if (trainWrongData[r, 3] == "N")
{
_wrongData.SetValue(wrongDataCounter, 0, trainWrongData[r, 0]);
_wrongData.SetValue(wrongDataCounter, 1, trainWrongData[r, 1]);
_wrongData.SetValue(wrongDataCounter, 2, trainWrongData[r, 2]);
_wrongData.SetValue(wrongDataCounter, 3, trainWrongData[r, 3]);
wrongDataCounter++;
}
}
_wrongData.ChangeHeader(0, "Row Num");
_wrongData.ChangeHeader(1, "Actual");
_wrongData.ChangeHeader(2, "Predict");
_wrongData.ChangeHeader(3, "Correct?");
_wrongData.WriteCSV(DateTime.Now.Ticks + ".csv");
return("Saved valResult.txt");
}
private string updateMatrixHeader(string matrixRef, int colToUpdate, string headerName)
{
var md = Value(matrixRef);
if (md.GetType() == typeof(string))
{
return(md.ToString());
}
MatrixData m = (MatrixData)md;
m.ChangeHeader(colToUpdate, headerName);
return("Updated column " + colToUpdate + " of " + matrixRef + " to " + headerName);
}
public string RunIris()
{
string output = "";
_rawData = new MatrixData("iris", false, true, ' ');
_rawData.ChangeHeader(0, "Speal.Length");
_rawData.ChangeHeader(1, "Speal.Width");
_rawData.ChangeHeader(2, "Petal.Length");
_rawData.ChangeHeader(3, "Petal.Width");
_rawData.ChangeHeader(4, "Species");
output += "Raw data:" + Environment.NewLine;
output += _rawData.Head().ToString(5, 16);
output += Environment.NewLine + Environment.NewLine;
output += "Normalizeing columns 1:4..." + Environment.NewLine;
_rawData.Normalize(0);
_rawData.Normalize(1);
_rawData.Normalize(2);
_rawData.Normalize(3);
output += "Normalised data:" + Environment.NewLine;
output += _rawData.Head().ToString(5, 16);
output += Environment.NewLine + Environment.NewLine;
_exemplarData = _rawData.GetExemplar(4, 3, 1);
output += "Exemplar data:" + Environment.NewLine;
output += _exemplarData.Head().ToString(5, 16);
output += Environment.NewLine + Environment.NewLine;
output += "Suffleing data..." + Environment.NewLine;
_exemplarData.Suffle();
output += Environment.NewLine;
output += "Setting trainig data as first 50 rows of suffled exemplar data..." + Environment.NewLine;
_trainingData = _exemplarData.CopyData(0, 0, 50);
output += "Trainig data:" + Environment.NewLine;
output += _trainingData.Head().ToString(5, 16);
output += Environment.NewLine + Environment.NewLine;
output += "Setting test data as next 50 rows of suffled exemplar data..." + Environment.NewLine;
_testingData = _exemplarData.CopyData(50, 0, 50);
output += "Test data:" + Environment.NewLine;
output += _testingData.Head().ToString(5, 16);
output += Environment.NewLine + Environment.NewLine;
output += "Setting validation data as next 50 rows of suffled exemplar data..." + Environment.NewLine;
_validationData = _exemplarData.CopyData(100, 0, 50);
output += "Validation data:" + Environment.NewLine;
output += _validationData.Head().ToString(5, 16);
output += Environment.NewLine + Environment.NewLine;
int num_inputs = 4; // from iris data set
int num_hidden = 1; // arbitary
int num_outputs = 3; // from iris data set
int epochs = 200; // For tute 3
double eta = 0.1; // learning_rate
output += "Initialising Neural Network with:" + Environment.NewLine;
output += num_inputs + " inputs, " + num_hidden + " hidden layers, " + num_outputs + " outputs, " + epochs + " epochs, " + eta + " learning eate" + Environment.NewLine;
Random rnd1 = new Random(102);
nn = new W4NeuralNetwork(num_inputs, num_hidden, num_outputs, rnd1);
nn.InitializeWeights(rnd1);
string dir = "Data\\";
nn.train(_trainingData.Data.ToJagged().ToDoubleArray(), _testingData.Data.ToJagged().ToDoubleArray(), epochs, eta, dir + "nnlog.txt");
_graphData = nn.GraphData;
double trainAcc = nn.Accuracy(_trainingData.Data.ToJagged().ToDoubleArray(), dir + "trainOut.txt");
string ConfusionTrain = nn.showConfusion(dir + "trainConfusion.txt");
_confusionMatrixTrain = nn.GetConfusionMatrix();
_outputMatrixTrain = new MatrixData(dir + "trainOut.txt", false, true, ' ');
double testAcc = nn.Accuracy(_testingData.Data.ToJagged().ToDoubleArray(), dir + "testOut.txt");
string ConfusionTest = nn.showConfusion(dir + "testConfusion.txt");
_confusionMatrixTest = nn.GetConfusionMatrix();
_outputMatrixTest = new MatrixData(dir + "testOut.txt", false, true, ' ');
double valAcc = nn.Accuracy(_validationData.Data.ToJagged().ToDoubleArray(), dir + "valOut.txt");
string ConfusionVal = nn.showConfusion(dir + "valConfusion.txt");
_confusionMatrixVal = nn.GetConfusionMatrix();
_outputMatrixVal = new MatrixData(dir + "valOut.txt", false, true, ' ');
trainAcc = trainAcc * 100;
testAcc = testAcc * 100;
valAcc = valAcc * 100;
output += Environment.NewLine;
output += "Train accuracy = " + trainAcc.ToString("F2") + Environment.NewLine;
output += "Test accuracy = " + testAcc.ToString("F2") + Environment.NewLine;
output += "Val accuracy = " + valAcc.ToString("F2") + Environment.NewLine;
output += Environment.NewLine;
output += "Train Confusion matrix \r\n" + ConfusionTrain + Environment.NewLine;
output += "Test Confusion matrix \r\n" + ConfusionTest + Environment.NewLine;
output += "Val Confusion matrix \r\n" + ConfusionVal + Environment.NewLine;
GenerateGraph();
return(output);
}
