/**************************************************
* Construction of .ann file
* (4)int32 count of layers
* for each layer:
*** (1)FunctionType type of layer
*** (4)int32 count of neurons
*** for each neuron:
***** (4)int32 size of input vector
***** (8 * size)double[] array of weights
**************************************************/
static public FeedForwardNet ReadNet(string filepath)
{
int position = 0;
FeedForwardNet result = new FeedForwardNet();
byte[] bytes = File.ReadAllBytes(filepath);
int layersCount = BitConverter.ToInt32(bytes, position);
position += 4;
for (int i = 0; i < layersCount; ++i)
{
Functions.FunctionType type =
(Functions.FunctionType)bytes[position];
++position;
int neuronsCount = BitConverter.ToInt32(bytes, position);
position += 4;
List <List <double> > toLayer = new List <List <double> >(neuronsCount);
for (int j = 0; j < neuronsCount; ++j)
{
int inputVectorSize = BitConverter.ToInt32(bytes, position);
List <double> weights = new List <double>(inputVectorSize);
position += 4;
for (int l = 0; l < inputVectorSize; ++l)
{
weights.Add(BitConverter.ToDouble(bytes, position));
position += 8;
}
toLayer.Add(weights);
}
result.AddLayer(new Layer(toLayer, true, type));
}
return(result);
}
static public void WriteNet(FeedForwardNet net, string netname, string filename)
{
Directory.CreateDirectory(netname);
string filepath = netname + @"/" + filename + ".ann";
List <byte> toWrite = new List <byte>();
List <Layer> Layers = net.GetLayers();
toWrite.AddRange(BitConverter.GetBytes(Layers.Count));
for (int i = 0; i < Layers.Count; ++i)
{
List <List <double> > weights = Layers[i].GetWeghts();
toWrite.Add((byte)Layers[i].GetLayerType());
toWrite.AddRange(BitConverter.GetBytes(weights.Count));
for (int j = 0; j < weights.Count; ++j)
{
toWrite.AddRange(BitConverter.GetBytes(weights[j].Count));
for (int l = 0; l < weights[j].Count; ++l)
{
toWrite.AddRange(BitConverter.GetBytes(weights[j][l]));
}
}
}
File.WriteAllBytes(filepath, toWrite.ToArray());
}
public void Run()
{
double[][] inputs =
{
new double[] { 0, 0 },
new double[] { 1, 0 },
new double[] { 0, 1 },
new double[] { 1, 1 }
};
double[][] outputs =
{
new double[] { 0 },
new double[] { 1 },
new double[] { 1 },
new double[] { 0 }
};
TrainingSet trainingSet = new TrainingSet(inputs, outputs);
IBackPropagationConstants backPropagationConstants = new BackPropagationConstants(learningRate: 0.25, momentum: 0.9, maxInitWeight: 0.5, outputTolerance: 0.1, maxIterations: 10000);
FeedForwardNet xorNet = new FeedForwardNet(new int[] { 2, 2, 1 }, backPropagationConstants.MaxInitWeight);
IBackPropagationAlgorithm backPropagationAlgorithm = new BackPropagationStandardAlgorithm(backPropagationConstants);
IBackPropagationTrainer backPropagationTrainer = new BackPropagationTrainer(xorNet, backPropagationAlgorithm, trainingSet);
backPropagationTrainer.FeedForwardTrain();
}
public static void Main(string[] args)
{
FeedForwardNet network = new FeedForwardNet(new int[] { 2, 2, 1 });
//FeedForwardNet network = new FeedForwardNet(new int[]{4,7,3});
List <Pattern> patterns = new List <Pattern>();
List <double[]> inputs = new List <double[]>();
List <double[]> expectedValues = new List <double[]>();
//Load patterns
//patterns = Util.LoadPatterns("../../Desktop/pima-indians-diabetes.data.csv",8);
patterns = Util.LoadPatterns("Patterns.csv", 2);
//patterns = Util.LoadPatterns("iris.data.csv",4);
foreach (Pattern p in patterns)
{
inputs.Add(p.Inputs());
expectedValues.Add(p.Outputs());
}
network.Learn(inputs, expectedValues);
}
static void Main(string[] args)
{
List <List <double> > inputs = ReadNetIO(@"input4.txt");
List <List <double> > outputs = ReadNetIO(@"output3.txt");
Shuffle(inputs);
Shuffle(outputs);
List <List <double> > testin = new List <List <double> >();
List <List <double> > testout = new List <List <double> >();
for (int i = 1; i < 11; ++i)
{
testin.Add(inputs[inputs.Count - i]);
testout.Add(outputs[outputs.Count - i]);
inputs.RemoveAt(inputs.Count - i);
outputs.RemoveAt(outputs.Count - i);
}
const bool newNet = true;
FeedForwardNet net;
if (newNet)
{
const double LearningRate = 0.1;
const int epochs = 10000;
const int batchSize = 1;
const int type = 1;
net = new FeedForwardNet();
if (type == 1)
{
net.AddSigmoidLayer(10, 4);
net.AddSigmoidLayer(5, 10);
net.AddSigmoidLayer(3, 5);
}
else if (type == 2)
{
net.AddTangentialLayer(10, 4);
net.AddTangentialLayer(5, 10);
net.AddTangentialLayer(3, 5);
}
else if (type == 3)
{
net.AddGaussianLayer(10, 4);
net.AddGaussianLayer(5, 10);
net.AddGaussianLayer(3, 5);
}
else if (type == 4)
{
net.AddGaussianLayer(10, 4);
net.AddSigmoidLayer(5, 10);
net.AddTangentialLayer(3, 5);
}
net.Train(inputs, outputs, LearningRate, epochs, batchSize);
}
else
{
net = ANNSerializer.ReadNet(@"first_net/1.ann");
}
for (int i = 0; i < outputs.Count; ++i)
{
List <double> result = net.Calculate(inputs[i]);
Console.ForegroundColor = ConsoleColor.White;
for (int j = 0; j < inputs[i].Count; ++j)
{
Console.Write(inputs[i][j] + " ");
}
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Write(i + " " + ConvertToIris(result) + " ");
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine(ConvertToIris(outputs[i]) + "\n");
}
Console.WriteLine("Tests:");
for (int i = 0; i < testin.Count; ++i)
{
List <double> result = net.Calculate(testin[i]);
Console.ForegroundColor = ConsoleColor.White;
for (int j = 0; j < testin[i].Count; ++j)
{
Console.Write(testin[i][j] + " ");
}
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Write(i + " " + ConvertToIris(result) + " ");
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine(ConvertToIris(testout[i]) + "\n");
}
}
