public void Train(double[] inputArray, double[] targetArray)
{
//Matrix.Matrix inputMatrix = new Matrix.Matrix(inputArray);
FillHiddenNeurons(inputArray);
//hiddenOutput.DisplayMatrix();
Matrix.Matrix outputsOutput = outputWeights * hiddenOutput;
if (useBias)
{
outputsOutput += biasOutput;
}
Matrix.Matrix targetMatrix = new Matrix.Matrix(targetArray);
Matrix.Matrix outputErrorsMatrix = targetMatrix - outputsOutput;
// mapMatrixLinearry(outputsOutput); //!!! do zmiany w wariancie 2 na normalne mapowanie
Matrix.Matrix gradients_output = outputErrorsMatrix * learningRate;
//gradients_output.HadamardProduct(outputsOutput);
//gradients_output.DisplayMatrix();
Matrix.Matrix hiddenTransposed = hiddenOutput.TransposeMatrix();
//hiddenTransposed.DisplayMatrix();
Matrix.Matrix outputs_deltas = gradients_output * hiddenTransposed;
//outputs_deltas.DisplayMatrix();
outputWeights += outputs_deltas;
biasOutput += gradients_output;
outputWeights += momentumMatrixOutput;
biasOutput += momentumMatrixOutputBias;
momentumMatrixOutput = outputs_deltas * momentumRate;
momentumMatrixOutputBias = gradients_output * momentumRate;
}
public void Train(double[] inputArray, double[] targetArray)
{
/*Random rnd = new Random();
* for (int i = 0; i < 10; ++i)
* {
* //wypełnianie macierzy c - centrów
* int index = rnd.Next(0, inp.row);
* for (int j = 0; j < 1; ++j)
* {
* centre.tab[i, j] = inp.tab[index, j];
* }
* //wypełnianie macierzy r - zasięgu
* range.tab[i, 0] = rnd.NextDouble() * 50;
* }*/
//Matrix.Matrix inputMatrix = new Matrix.Matrix(inputArray);
FillHiddenNeurons(inputArray);
//hiddenOutput.DisplayMatrix();
Matrix.Matrix outputsOutput = outputWeights * hiddenOutput;
Matrix.Matrix targetMatrix = new Matrix.Matrix(targetArray);
Matrix.Matrix outputErrorsMatrix = targetMatrix - outputsOutput;
mapMatrixLinearry(outputsOutput); //!!! do zmiany w wariancie 2 na normalne mapowanie
Matrix.Matrix gradients_output = outputErrorsMatrix * learningRate;
gradients_output.HadamardProduct(outputsOutput);
//gradients_output.DisplayMatrix();
Matrix.Matrix hiddenTransposed = hiddenOutput.TransposeMatrix();
//hiddenTransposed.DisplayMatrix();
Matrix.Matrix outputs_deltas = gradients_output * hiddenTransposed;
//outputs_deltas.DisplayMatrix();
outputWeights += outputs_deltas;
//Console.WriteLine("outputWeights: ");
//outputWeights.DisplayMatrix();
}
public void train(double[] inputArray, double[] targetArray)
{
Matrix.Matrix inputMatrix = new Matrix.Matrix(inputArray); // 3 x 1
Matrix.Matrix hiddenOutput = hiddenWeights * inputMatrix;
if (useBias)
{
hiddenOutput += biasHidden;
}
activationFunction(hiddenOutput);
//showHiddenOutputs(hiddenOutput);
Matrix.Matrix outputsOutput = outputWeights * hiddenOutput;
if (useBias)
{
outputsOutput += biasOutput;
}
activationFunction(outputsOutput);
Matrix.Matrix targetMatrix = new Matrix.Matrix(targetArray);
Matrix.Matrix outputErrorsMatrix = targetMatrix - outputsOutput;
mapMatrix(outputsOutput);
Matrix.Matrix gradients_output = outputErrorsMatrix * learningRate;
gradients_output.HadamardProduct(outputsOutput);
Matrix.Matrix hiddenTransposed = hiddenOutput.TransposeMatrix();
Matrix.Matrix outputs_deltas = gradients_output * hiddenTransposed;
//momentumMatrixOutput += outputs_deltas;
//momentumMatrixOutput *= momentumRate;
outputWeights += outputs_deltas;
//outputWeights += momentumMatrixOutput;
biasOutput += gradients_output;
//biasOutput += outputs_deltas;
//hidden layer errors
Matrix.Matrix outputWeights_transposed = outputWeights.TransposeMatrix();
Matrix.Matrix hiddenErrorsMatrix = outputWeights_transposed * outputErrorsMatrix;
mapMatrix(hiddenOutput);
Matrix.Matrix gradients_hidden = hiddenErrorsMatrix * learningRate;
gradients_hidden.HadamardProduct(hiddenOutput);
Matrix.Matrix hidden_deltas = gradients_hidden * inputMatrix.TransposeMatrix();
hiddenWeights += hidden_deltas;
biasHidden += gradients_hidden;
//biasHidden += hidden_deltas;
//MOMENTUM
outputWeights += momentumMatrixOutput;
hiddenWeights += momentumMatrixHidden;
biasOutput += momentumMatrixOutputBias;
biasHidden += momentumMatrixHiddenBias;
momentumMatrixOutput = outputs_deltas * momentumRate;
momentumMatrixHidden = hidden_deltas * momentumRate;
momentumMatrixOutputBias = gradients_output * momentumRate;
momentumMatrixHiddenBias = gradients_hidden * momentumRate;
}
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();
}