static void Main(string[] args)
{
/*Matrix.Matrix a = new Matrix.Matrix(5, 5);
* Matrix.Matrix b = new Matrix.Matrix(5, 5);
*
* a.RandomizeMatrix(-5, 5);
* a.DisplayMatrix();
* b = a.TransposeMatrix();
* Console.Write('\n');
* b.DisplayMatrix();*/
/*NeuralNetwork nn = new NeuralNetwork(3, 2, 1, true);
* int[] a = new int[3];
* for (int i = 0; i < 3; ++i)
* a[i] = i;
*
* Matrix.Matrix output = new Matrix.Matrix(1, 1);
*
* output = nn.feedForward(a);
* output.DisplayMatrix();*/
/*Matrix.Matrix a = new Matrix.Matrix(3, 3);
* a.RandomizeMatrix(-3, 3);
* a.DisplayMatrix();
* Console.Write('\n');
* nn.activationFunction(a);
* a.DisplayMatrix();*/
/*Matrix.Matrix a = new Matrix.Matrix(2, 1);
* Matrix.Matrix b = new Matrix.Matrix(1, 2);
* a.RandomizeMatrix(0, 5);
* b.RandomizeMatrix(0, 5);
*
* a.DisplayMatrix();
* b.DisplayMatrix();
*
*
* Matrix.Matrix c = a * b;
* c.DisplayMatrix();*/
/*int[] a = new int[3];
* for (int i = 0; i < 3; ++i)
* a[i] = i;
* Console.Write(a.Length);
* Matrix.Matrix m = new Matrix.Matrix(a, true);
* m.DisplayMatrix();*/
// XOR
/*NeuralNetwork nn = new NeuralNetwork(2, 4, 1, true);
*
* int[] input = new int[2];
* int[] target = new int[1];
* Random rnd = new Random();
*
* for (int i = 0; i < 10000; ++i)
* {
* input[0] = rnd.Next(0, 2);
* input[1] = rnd.Next(0, 2);
*
* target[0] = input[0] ^ input[1];
*
* //Console.WriteLine("\ninput0: " + input[0] + " input1: " + input[1] + " target: " + target[0]);
* nn.train(input, target);
* }
*
* input[0] = 0;
* input[1] = 0;
* target[0] = 0;
*
* Matrix.Matrix output = nn.feedForward(input);
* output.DisplayMatrix();
* Console.Write('\n');
*
* input[0] = 1;
* input[1] = 1;
* target[0] = 0;
*
* output = nn.feedForward(input);
* output.DisplayMatrix();
* Console.Write('\n');
*
* input[0] = 0;
* input[1] = 1;
* target[0] = 1;
*
* output = nn.feedForward(input);
* output.DisplayMatrix();
* Console.Write('\n');
*
* input[0] = 1;
* input[1] = 0;
* target[0] = 1;
*
* output = nn.feedForward(input);
* output.DisplayMatrix();
* Console.Write('\n');
*/
//ZADANIE 1
double[][] data = new double[4][];
data[0] = new double[] { 1, 0, 0, 0 };
data[1] = new double[] { 0, 1, 0, 0 };
data[2] = new double[] { 0, 0, 1, 0 };
data[3] = new double[] { 0, 0, 0, 1 };
//NeuralNetwork nn = new NeuralNetwork(4, 3, 4, true);
int n = 0;
double sum = 0;
Random rnd = new Random();
Matrix.Matrix output = new Matrix.Matrix(4, 1);
int epochs = 0;
double averageSquareOfEpochs = 0;
for (int i = 0; i < 20; ++i)
{
NeuralNetwork nn = new NeuralNetwork(4, 2, 4, true);
do
{
sum = 0;
//trenowanie
foreach (int j in Enumerable.Range(0, 4).OrderBy(x => rnd.Next()))
{
nn.train(data[j], data[j]);
}
for (int j = 0; j < 4; ++j)
{
output = nn.feedForward(data[j]);
for (int z = 0; z < 4; ++z)
{
sum += (output.tab[z, 0] - data[j][z]) * (output.tab[z, 0] - data[j][z]);
}
}
++epochs;
// Console.WriteLine("Mean squared error: " + sum / 2);
} while (sum / 2 > 0.1);
Console.WriteLine("epochs: " + epochs);
averageSquareOfEpochs += epochs;
epochs = 0;
}
averageSquareOfEpochs /= 20;
output.DisplayMatrix();
Console.WriteLine("averageSquareOfEpochs: " + averageSquareOfEpochs);
/* for (int i = 0; i < 30000; ++i)
* {
* foreach (int j in Enumerable.Range(0, 4).OrderBy(x => rnd.Next()))
* {
* nn.train(data[j], data[j]);
* //Console.WriteLine(j);
* }
*
* sum = 0;
*
*
* for (int j = 0; j < 4; ++j)
* {
* output = nn.feedForward(data[j]);
* for (int z = 0; z < 4; ++z)
* {
* //Console.WriteLine("(output.tab[z, 0]: " + (output.tab[z, 0] + " data[j][z]: " + data[j][z]));
*
* sum += (output.tab[z, 0] - data[j][z]) * (output.tab[z, 0] - data[j][z]);
* }
* //Console.WriteLine("Mean squared error: " + sum / 2);
* //sum = 0;
* }
*
* Console.WriteLine("Mean squared error: " + sum / 2);
*
*
* }*/
/*for (int i = 0; i < 4; ++i)
* {
* output = nn.feedForward(data[i]);
* output.DisplayMatrix();
* Console.Write('\n');
* }*/
Console.Read();
}
public void showHiddenOutputs(Matrix.Matrix a)
{
Console.WriteLine("Hidden outputs: ");
a.DisplayMatrix();
Console.Write('\n');
}
private void Form1_Load(object sender, EventArgs e)
{
epochs = 1000;
LoadFromFile(data);
//plot
//OxyPlot.WindowsForms.PlotView pv = new PlotView();
this.Controls.Add(pv);
PlotModel pm = new PlotModel();
pv.Model = pm;
LineSeries punktySerii = new LineSeries
{
LineStyle = LineStyle.None,
MarkerType = MarkerType.Diamond,
MarkerSize = 2,
MarkerStroke = OxyColors.Red,
Title = "Punkty treningowe"
};
LineSeries punktySieci = new LineSeries()
{
LineStyle = LineStyle.None,
MarkerType = MarkerType.Plus,
MarkerSize = 3,
MarkerStroke = OxyColors.Blue,
Title = "Punkty wyjściowe"
};
LineSeries punktyKresek = new LineSeries
{
Color = OxyColors.Blue,
StrokeThickness = 1
};
for (int i = 0; i < inputArray.Length; i++)
{
punktySerii.Points.Add(new DataPoint(inputArray[i], targetArray[i]));
}
//SIEĆ
Random rnd = new Random();
NeuralNetwork nn = new NeuralNetwork(1, 10, 1, data);
for (int i = 0; i < epochs; ++i)
{
foreach (int j in Enumerable.Range(0, 81).OrderBy(x => rnd.Next()))
{
double[] inp = new double[1];
double[] tar = new double[1];
inp[0] = inputArray[j];
tar[0] = targetArray[j];
nn.Train(inp, tar);
}
}
Matrix.Matrix output = new Matrix.Matrix(1, 1);
for (int i = 0; i < 81; ++i)
{
double[] inp = new double[1];
double[] d = new double[1];
inp[0] = inputArray[i];
output = nn.FeedForward(inp);
d[0] = inputArray[i];
punktySieci.Points.Add(new DataPoint(d[0], output.tab[0, 0]));
}
output.DisplayMatrix();
pm.Series.Add(punktySerii);
pm.Series.Add(punktySieci);
}
static void Main(string[] args)
{
Program p = new Program();
p.LoadFromFile();
Random rnd = new Random();
NeuralNetwork nn = new NeuralNetwork(4, 4, 3, true);
/*for (int j = 0; j < 90; ++j)
* {
* Array.Clear(targetArray, 0, 3);
* for (int z = 0; z < numberOfInputs; ++z)
* {
* inputArray[z] = classification_train[j][z];
* }
* targetArray[(int)classification_train[j][4] - 1] = 1;
* Console.WriteLine("inputArray: " + inputArray[0] + " " + inputArray[1] + " targetArray: " + targetArray[0] + " " + targetArray[1] + " " + targetArray[2]);
* }*/
double[] second = new double[] { 0, 1, 0 };
for (int i = 0; i < 1000; ++i)
{
foreach (int j in Enumerable.Range(0, 90).OrderBy(x => rnd.Next()))
{
Array.Clear(targetArray, 0, 3);
//wypełnianie całej inputArray na początek
for (int z = 0; z < numberOfInputs; ++z)
{
inputArray[z] = classification_train[j][z];
}
targetArray[(int)classification_train[j][4] - 1] = 1;
//Console.WriteLine("inputArray: " + inputArray[0] + " " + inputArray[1]);
/*if (classification_train[j][4] == 2)
* {
* Console.WriteLine("DWAAAAAAAAAAAAA");
* targetArray = second;
* }*/
nn.train(inputArray, targetArray);
}
}
Matrix.Matrix output = new Matrix.Matrix(3, 1);
Matrix.Matrix confusionMatrix = new Matrix.Matrix(3, 3);
double numberOfCorrect = 0;
double percentOfCorectness = 0;
int predictedOutput = 0;
for (int i = 0; i < 93; ++i)
{
for (int z = 0; z < numberOfInputs; ++z)
{
inputArray[z] = classification_test[i][z];
}
output = nn.feedForward(inputArray);
output = output.TransposeMatrix();
//POTRZEBNE DO LICZNIEA BŁĘDU ŚREDNIOKWADRATOWEGO
/*Array.Clear(targetArray, 0, 3);
* targetArray[(int)classification_test[i][4] - 1] = 1;
* Console.WriteLine(" targetArray: " + targetArray[0] + " " + targetArray[1] + " " + targetArray[2]);*/
//LICZENIE PROCENTA POPRAWNOŚCI
if (output.tab[0, 0] > output.tab[0, 1] && output.tab[0, 0] > output.tab[0, 2] && classification_test[i][4] == 1)
{
++numberOfCorrect;
}
else if (output.tab[0, 1] > output.tab[0, 0] && output.tab[0, 1] > output.tab[0, 2] && classification_test[i][4] == 2)
{
++numberOfCorrect;
}
else if (output.tab[0, 2] > output.tab[0, 0] && output.tab[0, 2] > output.tab[0, 1] && classification_test[i][4] == 3)
{
++numberOfCorrect;
}
predictedOutput = 0;
if (output.tab[0, 0] > output.tab[0, 1] && output.tab[0, 0] > output.tab[0, 2])
{
predictedOutput = 1;
}
else if (output.tab[0, 1] > output.tab[0, 0] && output.tab[0, 1] > output.tab[0, 2])
{
predictedOutput = 2;
}
else if (output.tab[0, 2] > output.tab[0, 0] && output.tab[0, 2] > output.tab[0, 1])
{
predictedOutput = 3;
}
//WYPEŁNIANIE MACIERZY POMYŁEK (confusionMatrix)
if (predictedOutput > 0)
{
confusionMatrix.tab[(int)classification_test[i][4] - 1, predictedOutput - 1]++;
}
output.DisplayMatrix();
}
percentOfCorectness = numberOfCorrect / 93;
percentOfCorectness *= 100;
//Console.WriteLine("\nNumber of correct: " + numberOfCorrect);
Console.WriteLine("\nPercentage of corectness: " + percentOfCorectness);
Console.WriteLine("\nConfusion matrix: ");
confusionMatrix.DisplayMatrix();
}