public void BackPropagate()
{
OutputLayer.CalculateErrors();
HiddenLayer.CalculateErrors();
HiddenLayer.AdjustWeights(LearningRate, Momentum);
InputLayer.AdjustWeights(LearningRate, Momentum);
}
/// <summary>
/// Constructs the NN from a given file.
/// </summary>
/// <param name="fileName"></param>
public DeepNeuralNetwork(string fileName)
{
try
{
using (StreamReader reader = new StreamReader(fileName))
{
string[] layerTokens = reader.ReadLine().Split(' ').Where(s => !string.IsNullOrWhiteSpace(s)).ToArray();
int[] layerCount = new int[layerTokens.Length];
for (int i = 0; i < layerTokens.Length; ++i)
{
layerCount[i] = int.Parse(layerTokens[i]);
}
InputLayer = new InputLayer(layerCount[0]);
//hidden layers
HiddenLayers = new HiddenLayer[layerCount.Length - 2];
for (int i = 1; i < layerCount.Length - 1; ++i)
{
var storage = ReadLayerFromFile(reader, layerCount[i]);
HiddenLayers[i - 1] = new HiddenLayer(layerCount[i], layerCount[i - 1], storage.w, storage.b);
}
//output layer
var stor = ReadLayerFromFile(reader, layerCount[layerCount.Length - 1]);
OutputLayer = new OutputLayer(layerCount[layerCount.Length - 1], layerCount[layerCount.Length - 2], stor.w, stor.b);
List <ComputedLayer> compLayers = new List <ComputedLayer>();
compLayers.AddRange(HiddenLayers);
compLayers.Add(OutputLayer);
ComputedLayers = compLayers.ToArray();
}
}
catch
{
throw new BadFileFormatException("Bad file format.");
}
}
public void Train(params double[] inputs)
{
int i = 0;
InputLayer.ForEach(a => a.Value = inputs[i++]);
HiddenLayer.ForEach(a => a.CalculateValue());
OutputLayer.ForEach(a => a.CalculateValue());
}
private void ForwardPropagate(params double[] inputs)
{
var i = 0;
InputLayer.ForEach(a => a.Value = inputs[i++]);
HiddenLayer.ForEach(a => a.CalculateValue());
OutputLayer.ForEach(a => a.CalculateValue());
}
public void BackPropagate(params double[] targets)
{
int i = 0;
OutputLayer.ForEach(a => a.CalculateGradient(targets[i++]));
HiddenLayer.ForEach(a => a.CalculateGradient());
HiddenLayer.ForEach(a => a.UpdateWeights(LearnRate, Momentum));
OutputLayer.ForEach(a => a.UpdateWeights(LearnRate, Momentum));
}
public HiddenLayer CreateHiddenLayer()
{
HiddenLayer hiddenLayer;
hiddenLayer = new HiddenLayer();
HiddenLayers.Add(hiddenLayer);
return(hiddenLayer);
}
private void InitHiddenLayerWithRandomValues(HiddenLayer layer)
{
foreach (var neuron in layer.Neurons.Cast <HiddenNeuron>())
{
neuron.Bias = 3 * MyRandom();
foreach (var axon in neuron.Inputs)
{
axon.Weight = 3 * MyRandom();
}
}
}
public NeuralNetworkManager(int maxNetworks, InputManager inputManager, OutputManager outputManager)
{
_maxNetworks = maxNetworks;
_hiddenLayer = new HiddenLayer(maxNetworks);
_outputLayer = new HiddenLayer(maxNetworks);
_inputManager = inputManager;
_outputManager = outputManager;
_networkLock = new object();
}
public Network(int nrInputNeurons, int nrHiddenNeurons, int nrOutputNeurons, double learningRate, double momentum, double goalErrorRate)
{
NrInputNeurons = nrInputNeurons;
NrHiddenNeurons = nrHiddenNeurons;
NrOutputNeurons = nrOutputNeurons;
LearningRate = learningRate;
Momentum = momentum;
GoalErrorRate = goalErrorRate;
InputLayer = new InputLayer(nrInputNeurons);
HiddenLayer = new HiddenLayer(nrHiddenNeurons);
OutputLayer = new OutputLayer(nrOutputNeurons);
}
/// <summary>
/// Constructs the structure of the NN with randomized weights and biasses.
/// </summary>
/// <param name="inputCount">number of input neurons</param>
/// <param name="outputCount">number of output neurons</param>
/// <param name="hiddenCount">an array of neurons count for the hidden layers</param>
public DeepNeuralNetwork(int inputCount, int outputCount, int[] hiddenCount)
{
InputLayer = new InputLayer(inputCount);
int prevLayerNeuronCount = inputCount;
HiddenLayers = new HiddenLayer[hiddenCount.Length];
for (int i = 0; i < hiddenCount.Length; ++i)
{
HiddenLayers[i] = new HiddenLayer(hiddenCount[i], prevLayerNeuronCount);
prevLayerNeuronCount = hiddenCount[i];
}
OutputLayer = new OutputLayer(outputCount, prevLayerNeuronCount);
List <ComputedLayer> compLayers = new List <ComputedLayer>();
compLayers.AddRange(HiddenLayers);
compLayers.Add(OutputLayer);
ComputedLayers = compLayers.ToArray();
}
public Network(int InputLayerSize, int[] HiddenLayerSizes, int OutputLayerSize, Function[] activationFuncs)
{
Random r = new Random();
//will create a network with InputLayerSize inputneurons, HiddenLayerSizes.count Hiddenlayers (Each with the size of the array at that position), and OutputLayerSize outputneurons
/*****************************
* InputNeurons
****************************/
InputLayer = new InputLayer(InputLayerSize, this);
/*****************************
* HiddenNeurons
****************************/
hiddenLayer = new HiddenLayer[HiddenLayerSizes.Length];
for (int i = 0; i < hiddenLayer.Length; i++) //for each layer
{
hiddenLayer[i] = new HiddenLayer(HiddenLayerSizes[i], this);
if (i == 0)
{
hiddenLayer[i].connectToInputLayer(InputLayer);//connect the hiddenlayer to the inputlayer
}
else
{
hiddenLayer[i].connectToInputLayer(hiddenLayer[i - 1]);//connect the hiddenlayer to the hiddenlayer before
}
hiddenLayer[i].ActivationFunction = activationFuncs[i];
}
/*****************************
* OutputNeurons
****************************/
outputLayer = new OutputLayer(OutputLayerSize, this);
outputLayer.connectToInputLayer(hiddenLayer[HiddenLayerSizes.Length - 1]);
outputLayer.ActivationFunction = activationFuncs[activationFuncs.Length - 1];
this.RandomizeAllWeights();
this.DatabaseID = db.getNetworkID();
}
public NN_MultiLayerPerceptron(int inputCount, int hiddenLayerCount, int hiddenNeuronCount, int outputCount)
{
NetworkType = NetworkTypes.MultiLayerPerceptron;
for (var i = 0; i < inputCount; i++)
{
InputLayer.Neurons.Add(new Neuron());
}
for (var i = 0; i < hiddenLayerCount; i++)
{
var hiddenLayer = new HiddenLayer();
for (var j = 0; j < hiddenNeuronCount; j++)
{
hiddenLayer.Neurons.Add(new Neuron());
}
HiddenLayers.Add(new HiddenLayer());
}
for (var i = 0; i < outputCount; i++)
{
OutputLayer.Neurons.Add(new Neuron());
}
Layers.Add(InputLayer);
Layers.AddRange(HiddenLayers);
Layers.Add(OutputLayer);
}
public void FeedForward()
{
HiddenLayer.CalculateNeuronValues();
OutputLayer.CalculateNeuronValues();
}
