public layer(int previousLayerSize, int numberOfNeurons, Perceptron.myDelegate activationFunction)
{
this.size = numberOfNeurons;
values = new double[1, numberOfNeurons];
perceptron = new Perceptron(previousLayerSize, numberOfNeurons, activationFunction);
perceptron.randomScalesGenerate();
}
public NeuralNetwork(int inputSize, int outputSize, Perceptron.myDelegate activationFunction)
{
this.inputSize = inputSize;
this.outputSize = outputSize;
this.activationFunction = activationFunction;
LayerCreateInputOutput(inputSize, outputSize);
}
public double[,] values; //wartosci warstwy
public LayerN(int previous, int neurons_nbLayer, Perceptron.myDelegate activationFunction)
{
this.size = neurons_nbLayer;
values = new double[1, neurons_nbLayer];
perceptron = new Perceptron(previous, neurons_nbLayer, activationFunction);
perceptron.scalesGen();
}
public static void TrainingNetwork(ref NeuralNetwork nn, Perceptron.myDelegate activationFunction, List <TrainingData> list)
{
foreach (var l in list)
{
nn.BackPropagation(l.input, l.output, activationFunction);
}
}
static void Main(string[] args)
{
activationFunction = new Perceptron.myDelegate(Perceptron.sigmodFunction);
double[] trainingData = new double[] { 3, 4, 5 };
Task1(trainingData);
Task2(trainingData);
Console.ReadKey();
}
private double[,] activate(double[,] input, Perceptron.myDelegate activationFunction, bool deriv = false)
{
for (int i = 0; i < input.GetLength(0); i++)
{
for (int j = 0; j < input.GetLength(1); j++)
{
input[i, j] = activationFunction(input[i, j], deriv);
}
}
return(input);
}
public NeuralNetwork(int x, int y, Perceptron.myDelegate activationFunction)
{
this.input_ = x;
this.output_ = y;
this.activationFunction = activationFunction;
//tworzenie warstwy wej+wyj
layers = new LayerN[2];
layers[0] = new LayerN(0, x, activationFunction);
layers[1] = new LayerN(x, y, activationFunction);
}
public void BackPropagation(double[] input, double[] output, Perceptron.myDelegate activationFunction)
{
var error_ = error(new TrainingData(input, output));
int n_layers = layers.Length - 1;
for (int i = 0; i < n_layers; i++)
{
var activate_values = activate(layers[n_layers - i].values, activationFunction, true);
var delta = MultiplyVector(error_, activate_values);
var scales_trans = Trans(layers[n_layers - i].perceptron.scales);
error_ = Multiply(delta, scales_trans);
var multiply_matrix = MultiplyMatrixSc(layers[n_layers - i - 1].values, Trans(delta));
layers[n_layers - i].perceptron.scales = Substract(layers[n_layers - i].perceptron.scales, Trans(multiply_matrix));
}
}
/// <summary>
/// Propagacja wsteczna
/// </summary>
/// <param name="input">Dane wejściowe</param>
/// <param name="output">Dane wyjściowe</param>
public void PropagateBack(double[] input, double[] output, Perceptron.myDelegate activationFunction)
{
var error = ErrorCalculate(new TrainingData(input, output));
int numberOfLayers = layerList.Length - 1;
for (int i = 0; i < numberOfLayers; i++)
{
var valuesActivationFunction = ExecuteActivationFunction(layerList[numberOfLayers - i].values, activationFunction, true);
var delta = MatrixHelper.VectorScalar(error, valuesActivationFunction);
var scalesMatrixTransposition = MatrixHelper.MatrixTransposition(layerList[numberOfLayers - i].perceptron.scalesMatrix);
error = MatrixHelper.MatrixMultiply(delta, scalesMatrixTransposition);
var matrixMultiplied = MatrixHelper.MatrixScalar(layerList[numberOfLayers - i - 1].values, MatrixHelper.MatrixTransposition(delta));
layerList[numberOfLayers - i].perceptron.scalesMatrix = MatrixHelper.MatrixSubstraction(layerList[numberOfLayers - i].perceptron.scalesMatrix, MatrixHelper.MatrixTransposition(matrixMultiplied));
}
}
