public Example[] parseDatasetFile(string filename)
{
string[] lines = System.IO.File.ReadAllLines(filename);
string[] dimensions = lines[0].Split(' ');
Example.IMG_HEIGHT = Int32.Parse(dimensions[0]);
Example.IMG_WIDTH = Int32.Parse(dimensions[1]);
int datasetSize = Int32.Parse(lines[1]);
Example[] dataset = new Example[datasetSize];
for (int lineIndex = 2, exampleIndex = 0; exampleIndex < datasetSize;
lineIndex += Example.IMG_HEIGHT + 1, exampleIndex++)
{
char letter = Char.Parse(lines[lineIndex]);
int[,] imageBits = new int[Example.IMG_HEIGHT,Example.IMG_WIDTH];
for (int i = 0; i < Example.IMG_HEIGHT; i++)
{
string[] matrixRow = lines[lineIndex + 1 + i].Split(' ');
for (int j = 0; j < Example.IMG_WIDTH; j++)
{
imageBits[i,j] = Int32.Parse(matrixRow[j]);
}
}
//Console.WriteLine("Loading Examples");
//Console.WriteLine(exampleIndex + "/" + datasetSize);
dataset[exampleIndex] = new Example(imageBits, letter);
}
return dataset;
}
public IFitness CreateFitness(Example[] dataset, int numInputs, int numOutputs,
int numHiddenLayers, int[] numNeuronsPerHiddenLayer,
double LEARNING_RATE = 0.01, double MOMENTUM = 0.0)
{
fitness = new NetworkFitness(ref dataset,
numInputs, numOutputs,
numHiddenLayers, numNeuronsPerHiddenLayer,
LEARNING_RATE, MOMENTUM);
return fitness;
}
public static double CalculateError(ref Example[] dataset, ref NeuralNetwork network)
{
double error = 0.0;
foreach (Example example in dataset)
{
network.classify(example.ToNetworkInput());
error += network.squaredError(example.ToNetworkOutput());
}
return error * 0.5;
}
// return average error of all partition errors
public double CalculatePrecision(ref Example[] set)
{
double sum = 0.0;
for (int i = 0; i < this.numTests; i++)
{
Console.WriteLine("Partition No. " + i);
sum += this.CalculatePrecisionPartition(ref set, i);
}
Console.WriteLine("Avg total error = " + (sum / this.numTests));
return sum / this.numTests;
}
public NetworkFitness(ref Example[] _dataset, int _numInputs, int _numOutputs,
int _numHiddenLayers, int[] _numNeuronsPerHiddenLayer,
double _LEARNING_RATE = 0.01, double _MOMENTUM = 0.0)
: base()
{
this.dataset = _dataset;
this.numInputs = _numInputs;
this.numOutputs = _numOutputs;
this.numHiddenLayers = _numHiddenLayers;
this.numNeuronsPerHiddenLayer = _numNeuronsPerHiddenLayer;
this.LEARNING_RATE = _LEARNING_RATE;
this.MOMENTUM = _MOMENTUM;
}
public CrossValidation(Example[] _dataset, int _numTests, ref CharacterRecognition _cr, Random seed)
{
this.seed = seed;
this.numTests = _numTests;
this.datasetPartitions = new List<Example>[this.numTests];
for (int n = 0; n < this.numTests; n++)
{
this.datasetPartitions[n] = new List<Example>();
}
for (int i = 0; i < _dataset.Length; i++)
{
this.datasetPartitions[i % this.numTests].Add(_dataset[i]);
}
this.cr = _cr;
}
public void Initialize(Example[] examples)
{
this.networks = new NeuralNetwork[this.numNetworks];
for (int i = 0; i < this.numNetworks; i++)
{
NetworkEvolution evolution = new NetworkEvolution(ref examples,
this.networkNumInputs, this.networkNumOutputs,
this.networkNumHiddenLayers, this.networkNumNeuronsPerHiddenLayer, seed);
networks[i] = evolution.EvolveNetwork();
/*foreach (Example example in examples)
{
networks[i].learn(example.ToNetworkInput(), example.ToNetworkOutput());
}*/
Console.WriteLine("Network No. " + i);
Console.WriteLine(DateTime.Now.ToString());
}
}
// return average error per partition
private double CalculatePrecisionPartition(ref Example[] examples, int i)
{
Example[] testSet = this.datasetPartitions[i].ToArray();
List<Example> trainSet = new List<Example>();
for (int j = 0; j < this.datasetPartitions.Length; j++)
{
if (i == j % this.numTests)
continue;
trainSet.AddRange(this.datasetPartitions[j]);
}
Example[] trainSetArray = trainSet.ToArray();
OCR.Shuffle(trainSetArray,seed);
this.cr.Initialize(trainSetArray);
double sumErrors = 0.0;
int sumErrorsLetters = 0;
int sumBigger = 0;
foreach (Example example in testSet)
{
double[] output = this.cr.RecognizeCharacter(example.ToNetworkInput());
//Console.WriteLine("Output is " + Array.IndexOf(output, output.Max()));
//Console.WriteLine("Correct is " + example.letterToInt() + "\n");
//Console.WriteLine("Correct is '" + example.letter +"' - int(" + example.letterToInt() + ")\n");
for (int x = 0; x < output.Length; x++)
{
sumBigger += (output[x] > output[example.letterToInt()] ? 1 : 0);
//Console.Write("" + x + ": \t" + output[x] + "\n");
}
//Console.Write("" + example.letterToInt() + "-" + Array.IndexOf(output, output.Max()) + "; ");
sumErrorsLetters += (example.letterToInt() == Array.IndexOf(output, output.Max()) ? 0 : 1);
sumErrors += example.SquaredError(output);
}
Console.WriteLine("Avg error = " + (sumErrors * 0.5 / (double)testSet.Length));
Console.WriteLine("Avg error (letter index) = " + ((double)sumErrorsLetters / (double)testSet.Length));
Console.WriteLine("Avg error (bigger index) = " + ((double)sumBigger / (double)testSet.Length));
Console.WriteLine();
this.cr.SaveToDirectory(@"C:\Users\Dimiter\Desktop\", "nn" + i + "_");
return sumErrors * 0.5 / testSet.Length;
}
