public void ApplyLearning(INeuralLayer layer, ref double learningRate)
{
foreach (KeyValuePair<INeuronSignal, NeuralFactor> m in m_input)
m.Value.ApplyWeightChange(ref learningRate);
m_bias.ApplyWeightChange(ref learningRate);
}
public void InitializeLearning(INeuralLayer layer)
{
foreach (KeyValuePair<INeuronSignal, NeuralFactor> m in m_input)
m.Value.ResetWeightChange();
m_bias.ResetWeightChange();
}
public NeuralCell(INeuralLayer layer, Type func, int axonsCount, double skew)
{
_layer = layer;
_axonsCount = axonsCount;
_weights = new double[axonsCount];
for (var i = 0; i < axonsCount; i++)
{
_weights[i] = 0;
}
_function = ((IActivationFunction)Activator.CreateInstance(func))?.Create(this, skew) ?? throw new NeuralTypeException(typeof(IActivationFunction), func);
}
public void Pulse(INeuralLayer layer)
{
lock (this)
{
m_output = 0;
foreach (KeyValuePair <INeuronSignal, NeuralFactor> item in m_input)
{
m_output += item.Key.Output * item.Value.Weight;
}
m_output += m_bias.Weight * BiasWeight;
m_output = Sigmoid(m_output);
}
}
public void Pulse(INeuralLayer layer)
{
lock (this)
{
m_output = 0;
foreach (KeyValuePair <INeuronSignal, NeuralFactor> item in m_input)
{
m_output += item.Key.Output * item.Value.Weight;
}
m_output += m_bias.Weight;
m_output = aktivationFunction.ActivateFunction(m_output);
}
}
public void Initialize(int randomSeed, int inputNeuronCount,
int hiddenNeuronCount, int outputNeuronCount)
{
int i, j;
Random rand;
// initializations
rand = new Random(randomSeed);
m_inputLayer = new NeuralLayer();
m_outputLayer = new NeuralLayer();
m_hiddenLayer = new NeuralLayer();
for (i = 0; i < inputNeuronCount; i++)
{
m_inputLayer.Add(new Neuron(0));
}
for (i = 0; i < outputNeuronCount; i++)
{
m_outputLayer.Add(new Neuron(rand.NextDouble()));
}
for (i = 0; i < hiddenNeuronCount; i++)
{
m_hiddenLayer.Add(new Neuron(rand.NextDouble()));
}
// wire-up input layer to hidden layer
for (i = 0; i < m_hiddenLayer.Count; i++)
{
for (j = 0; j < m_inputLayer.Count; j++)
{
m_hiddenLayer[i].Input.Add(m_inputLayer[j],
new NeuralFactor(rand.NextDouble()));
}
}
// wire-up output layer to hidden layer
for (i = 0; i < m_outputLayer.Count; i++)
{
for (j = 0; j < m_hiddenLayer.Count; j++)
{
m_outputLayer[i].Input.Add(m_hiddenLayer[j],
new NeuralFactor(rand.NextDouble()));
}
}
}
protected virtual void InitializeData(INeuralLayer <double> layer, double[] values)
{
if (values == null)
{
for (int i = 0; i < layer.Count; ++i)
{
layer[i].Value = 0;
}
}
else
{
for (int i = 0; i < layer.Count; ++i)
{
layer[i].Value = values[i];
}
}
}
public override void Pulse(INeuralLayer <double> source)
{
lock (key)
{
double newValue = 0;
foreach (IDendrite <double> dendrite in this.Inputs)
{
newValue += dendrite.Output.Value * dendrite.DendriteWeight.Weight;
}
newValue += this.Bias.Output.Value * this.Bias.DendriteWeight.Weight;
// Run Event before setting new value
this.OnNeuronValueChange?.Invoke(this, new NNEventArgs(null, source, this, null, newValue));
this.Value = newValue;
}
}
public override void BuildNetwork(int inputNeurons, IEnumerable <int> hiddenLayersNeurons, int outputNeurons)
{
// Prepare Input
this.InputLayer = this.BuildLayer(inputNeurons);
// Prepare Hidden Layers
this.HiddenLayers = new List <INeuralLayer <double> >();
if (hiddenLayersNeurons != null)
{
foreach (int neuronsInLayer in hiddenLayersNeurons)
{
INeuralLayer <double> hiddenLayer = this.BuildLayer(neuronsInLayer);
this.HiddenLayers.Add(hiddenLayer);
}
}
// Prepare Output
this.OutputLayer = this.BuildLayer(outputNeurons);
}
public void Initialize(int seed, int inputNeuronCount, int hiddenNeuronCount, int outputNeuronCount)
{
int i, layerCount;
Random rnd;
INeuralLayer layer;
rnd = new Random(seed);
m_inputLayer = new NeuralLayer();
m_outputLayer = new NeuralLayer();
m_hiddenLayer = new NeuralLayer();
for (i = 0; i < inputNeuronCount; i++)
{
m_inputLayer.Add(new Neuron());
}
for (i = 0; i < outputNeuronCount; i++)
{
m_outputLayer.Add(new Neuron());
}
for (i = 0; i < hiddenNeuronCount; i++)
{
m_hiddenLayer.Add(new Neuron());
}
// input layer to hidden layer
foreach (INeuron hiddenNeuron in m_hiddenLayer)
{
foreach (INeuron inputNeuron in m_inputLayer)
{
hiddenNeuron.Input.Add(inputNeuron, new NeuralFactor(rnd.NextDouble()));
}
}
// output neuron to hidden layer
foreach (INeuron outputNeuron in m_outputLayer)
{
foreach (INeuron hiddenNeuron in m_hiddenLayer)
{
outputNeuron.Input.Add(hiddenNeuron, new NeuralFactor(rnd.NextDouble()));
}
}
}
private void AdjustOutputLayerWeightChange(INeuralLayer <double> layer)
{
INeuron <double> outputNeuron, neuron;
for (int i = 0; i < layer.Count; ++i)
{
neuron = layer[i];
for (int j = 0; j < this.Output.Count; ++j)
{
outputNeuron = this.Output[j /*neuron*/];
double newDendriteWeight = outputNeuron[i].DendriteWeight.Weight + (this.LearningRate * this.Output[j].Error * neuron.Value);
// Run an Event.
outputNeuron.OnDendriteWeightChange?.Invoke(this, new NNEventArgs(this, layer, outputNeuron, outputNeuron[i], newDendriteWeight));
outputNeuron[i].DendriteWeight.Weight = newDendriteWeight;
outputNeuron.Bias.DendriteWeight.Delta += this.LearningRate * this.Output[j].Error * outputNeuron.Bias.DendriteWeight.Weight;
}
}
}
public virtual INeuralCell Create(INeuralLayer layer, Type func, int axonsCount, double skew) => new NeuralCell(layer, func, axonsCount, skew);
public void Pulse(INeuralLayer layer)
{
lock (this)
{
m_output = 0;
foreach (KeyValuePair<INeuronSignal, NeuralFactor> item in m_input)
m_output += item.Key.Output * item.Value.Weight;
m_output += m_bias.Weight;
m_output = Sigmoid(m_output);
}
}
public void OnDeserialize(INeuralLayer layer)
{
_layer = layer;
}
private void BackPropagation(double[] wantedResults)
{
int i, j;
double currentValue, error;
INeuron <double> outputNeuron, inputNeuron, hiddenNeuron, neuron;
// Calculate output error values
i = j = 0;
for (i = 0; i < this.Output.Count; ++i)
{
INeuron <double> localNeuron = this.Output[i];
currentValue = localNeuron.Value;
localNeuron.Error = (wantedResults[i] - currentValue) * currentValue * (1.0F - currentValue);
}
// Calculate hidden layers error values
i = j = 0;
foreach (INeuralLayer <double> layer in this.HiddenLayers)
{
for (i = 0; i < layer.Count; ++i)
{
neuron = layer[i];
error = 0;
for (j = 0; j < this.Output.Count; ++j)
{
outputNeuron = this.Output[j];
error += outputNeuron.Error * outputNeuron[i /*neuron*/].DendriteWeight.Weight * neuron.Value * (1.0 - neuron.Value);
}
neuron.Error = error;
}
error = 0;
}
// Adjust output layer weight change
i = j = 0;
if (this.HiddenLayers.Count > 0)
{
foreach (INeuralLayer <double> layer in this.HiddenLayers)
{
this.AdjustOutputLayerWeightChange(layer);
}
}
else
{
this.AdjustOutputLayerWeightChange(this.Output);
}
// Adjust first hidden layer weight change
if (this.HiddenLayers.Count > 0)
{
INeuralLayer <double> hiddenLayer = this.HiddenLayers.ElementAt(0);
for (i = 0; i < this.Input.Count; ++i)
{
inputNeuron = this.Input[i];
for (j = 0; j < hiddenLayer.Count; ++j)
{
hiddenNeuron = hiddenLayer[j];
hiddenNeuron[i /*inputNeuron*/].DendriteWeight.Weight += this.LearningRate * hiddenNeuron.Error * inputNeuron.Value;
hiddenNeuron.Bias.DendriteWeight.Delta += this.LearningRate * hiddenNeuron.Error * inputNeuron.Bias.DendriteWeight.Weight;
}
}
}
}
public NeuralLayerException(INeuralLayer layer, double[] input, string message) : base(message)
{
Layer = layer;
}
public virtual INeuralBias Create(INeuralLayer layer) => new NeuralBias(layer);
public NNEventArgs(INeuralNetwork <double> network, INeuralLayer <double> layer, INeuron <double> neuron, IDendrite <double> dendrite, double value) :
base(network, layer, neuron, dendrite, value)
{
}
public override void Initialize(INeuralLayer <double> input, ICollection <INeuralLayer <double> > hiddenLayers, INeuralLayer <double> output)
{
this.Input = input;
this.HiddenLayers = hiddenLayers;
this.Output = output;
// Connect layers
if (this.HiddenLayers != null && this.HiddenLayers.Count > 0) // There is at least one hidden layer
{
this.ConnectLayers(this.Input, this.HiddenLayers.ElementAt(0));
for (int i = 1; i < this.HiddenLayers.Count; ++i)
{
var layerInput = this.HiddenLayers.ElementAt(i - 1);
var layerOutput = this.HiddenLayers.ElementAt(i);
this.ConnectLayers(layerInput, layerOutput);
}
// Connect last hidden with output
this.ConnectLayers(this.HiddenLayers.ElementAt(this.HiddenLayers.Count - 1), this.Output);
}
else
{
this.ConnectLayers(this.Input, this.Output);
}
}
public abstract void Initialize(INeuralLayer <TNeuronDataType> input, ICollection <INeuralLayer <TNeuronDataType> > hiddenLayers, INeuralLayer <TNeuronDataType> output);
public void ApplyLearning(INeuralLayer layer)
{
}
public override void ApplyLearning(INeuralLayer <double> source)
{
// Nothing here
}
public void Initialize(int randomSeed)
{
var random = new Random(randomSeed);
_inputLayer = new NeuralLayer {
Name = "InputLayer"
};
_outputLayer = new NeuralLayer {
Name = "OutputLayer"
};
_hiddenLayers = new List <INeuralLayer>();
foreach (var hiddenLayer in NetConfiguration.HiddenLayerNodes)
{
_hiddenLayers.Add(new NeuralLayer {
Name = $"HiddenLayer{hiddenLayer.Key}"
});
}
for (var i = 0; i < NetConfiguration.NrOfInputNeurons; i++)
{
_inputLayer.Add(new Neuron(0));
}
for (var i = 0; i < NetConfiguration.NumberOfOutputNeurons; i++)
{
_outputLayer.Add(new Neuron(random.NextDouble()));
}
_inputLayer.OutputLayer = _hiddenLayers.First();
for (var i = 0; i < NetConfiguration.HiddenLayerNodes.Count; i++)
{
var nrOfNodesInLayer = NetConfiguration.HiddenLayerNodes.Values.ToArray()[i];
for (var j = 0; j < nrOfNodesInLayer; j++)
{
_hiddenLayers[i].Add(new Neuron(random.NextDouble()));
}
}
// wire-up the hidden layers
foreach (var hiddenLayer in _hiddenLayers)
{
var index = _hiddenLayers.IndexOf(hiddenLayer);
hiddenLayer.InputLayer = index == 0 ? _inputLayer : _hiddenLayers[index - 1];
hiddenLayer.OutputLayer = index < _hiddenLayers.Count - 1 ? _hiddenLayers[index + 1] : _outputLayer;
foreach (var hiddenNode in hiddenLayer)
{
foreach (var inputNode in hiddenLayer.InputLayer)
{
hiddenNode.Input.Add(inputNode, new NeuralFactor(random.NextDouble()));
}
}
}
_outputLayer.InputLayer = _hiddenLayers.Last();
// wire-up output layer to hidden layer
foreach (var outputNode in _outputLayer)
{
foreach (var hiddenNode in _outputLayer.InputLayer)
{
outputNode.Input.Add(hiddenNode, new NeuralFactor(random.NextDouble()));
}
}
}
public NeuralBias(INeuralLayer layer)
{
_layer = layer;
}
