protected void CreateNeurons(int inputSize, int[] hiddenSizes, int outputSize)
{
for (var i = 0; i < inputSize; i++)
{
InputLayer.Add(new Neuron());
}
var firstHiddenLayer = new List <Neuron>();
for (var i = 0; i < hiddenSizes[0]; i++)
{
firstHiddenLayer.Add(new Neuron(InputLayer, HiddenActivationType));
}
HiddenLayers.Add(firstHiddenLayer);
for (var i = 1; i < hiddenSizes.Length; i++)
{
var hiddenLayer = new List <Neuron>();
for (var j = 0; j < hiddenSizes[i]; j++)
{
hiddenLayer.Add(new Neuron(HiddenLayers[i - 1], HiddenActivationType));
}
HiddenLayers.Add(hiddenLayer);
}
for (var i = 0; i < outputSize; i++)
{
OutputLayer.Add(new Neuron(HiddenLayers.Last(), OutputActivationType));
}
}
public Network BuildNetwork()
{
for (int i = 0; i < _inputNodeInitialCount; i++)
{
var inputNode = new InputNode(i);
_inputNodes.Add(inputNode);
}
for (int i = 0; i < _outPutNodeInitialCount; i++)
{
var outputNode = new OutputNode(i, _activationFunction, _weightAdjustFunction);
_outputNodes.Add(outputNode);
}
for (int i = 0; i < _hiddenLayerInitialCount; i++)
{
_hiddenNodes[i] = new List <HiddenNode>();
for (int j = 0; j < _hiddenNodePerLayerInitialCount; j++)
{
_hiddenNodes[i].Add(new HiddenNode(j, _activationFunction, _weightAdjustFunction, _getRandom));
}
if (i == 0)
{
_hiddenNodes[i].ForEach((o) =>
{
o.AddInputNodes(_inputNodes);
});
}
else
{
_hiddenNodes[i].ForEach((o) =>
{
o.AddInputNodes(_hiddenNodes[i - 1]);
});
}
}
_outputNodes.ForEach((o) =>
{
if (_hiddenLayerInitialCount == 0 || _hiddenNodePerLayerInitialCount == 0)
{
o.AddInputNodes(_inputNodes);
}
else
{
o.AddInputNodes(_hiddenNodes[_hiddenLayerInitialCount - 1]);
}
});
return(this);
}
public NeuralGeneNode AddInputNode(NeuralActivationFunction _neuralActivationFunctions)
{
if (InputLayer == null)
{
InputLayer = new List <NeuralGeneNode>();
}
if (nodes == null)
{
nodes = new List <NeuralGeneNode>();
}
NeuralGeneNode tmpNode = new NeuralGeneNode(_neuralActivationFunctions, nodes.Count + 1, NeuralNodeType.Input);
InputLayer.Add(tmpNode);
nodes.Add(tmpNode);
return(tmpNode);
}
public void CreateLayers(int inputSize, int hiddenSize, int outputSize)
{
for (var i = 0; i < inputSize; i++)
{
InputLayer.Add(new InputNeuron());
}
for (var i = 0; i < hiddenSize; i++)
{
HiddenLayer.Add(new WorkingNeuron());
}
for (var i = 0; i < outputSize; i++)
{
OutputLayer.Add(new WorkingNeuron());
}
GenerateFullMesh(new Random());
}
public void AddInputsNode(int _inputSize, NeuralActivationFunction _neuralActivationFunctions)
{
if (InputLayer == null)
{
InputLayer = new List <NeuralGeneNode>();
}
if (nodes == null)
{
nodes = new List <NeuralGeneNode>();
}
for (int i = 0; i < _inputSize; i++)
{
NeuralGeneNode tmpNode = new NeuralGeneNode(_neuralActivationFunctions, i + 1, NeuralNodeType.Input);
InputLayer.Add(tmpNode);
nodes.Add(tmpNode);
}
}
public NeuralNet(int inputNumbers, int outputNumbers, int hiddenNumbers, int hiddenLayerNumbers = 1, float learnRate = 0.1f, float momentum = 0.9f)
{
for (int i = 0; i < inputNumbers; i++)
{
InputLayer.Add(new Neuron());
}
for (int i = 0; i < hiddenLayerNumbers; i++)
{
HiddenLayer.Add(new List <Neuron>());
for (int j = 0; j < hiddenNumbers; j++)
{
HiddenLayer[i].Add(new Neuron(i == 0 ? InputLayer : HiddenLayer[i - 1]));
}
}
for (int i = 0; i < outputNumbers; i++)
{
InputLayer.Add(new Neuron(HiddenLayer[hiddenLayerNumbers - 1]));
}
}
public Network(int inputSize, int[] hiddenSizes, int outputSize, double learnRate = 0.4, double momentum = 0.9)
{
this.LearnRate = learnRate;
this.Momentum = momentum;
this.InputLayer = new List <Neuron>();
this.HiddenLayers = new List <List <Neuron> >();
this.OutputLayer = new List <Neuron>();
for (var i = 0; i < inputSize; i++)
{
InputLayer.Add(new Neuron());
}
var firstHiddenLayer = new List <Neuron>();
for (var i = 0; i < hiddenSizes[0]; i++)
{
firstHiddenLayer.Add(new Neuron(InputLayer));
}
HiddenLayers.Add(firstHiddenLayer);
for (var i = 1; i < hiddenSizes.Length; i++)
{
var hiddenLayer = new List <Neuron>();
for (var j = 0; j < hiddenSizes[i]; j++)
{
hiddenLayer.Add(new Neuron(HiddenLayers[i - 1]));
}
HiddenLayers.Add(hiddenLayer);
}
for (var i = 0; i < outputSize; i++)
{
OutputLayer.Add(new Neuron(HiddenLayers.Last()));
}
}
public void AddInputNeuron(InputNeuron neuron) => InputLayer.Add(neuron);
public void CalculateOutputSigmoidMultiLayerTest()
{
// 0 0 1 => 0
// 1 1 1 => 1
// 1 0 1 => 1
// 0 1 1 => 0
// test
// 1 0 0 => ?
Random r = new Random();
Func <double> getRandom = (() => { return(r.NextDouble()); });
var weightAdjust = new Func <TrainingCalcModel, double>((m) =>
{
return(m.Error * m.Input * m.ActualOutput * (1 - m.ActualOutput));
});
var sigFunction = FunctionFactory.GetActivationFunction(eActivationFunc.Sigmoid);
var step = new Func <double, double>((z) =>
{
return(z > 0.0 ? 1 : 0);
});
var inputNodes1 = new InputLayer();
inputNodes1.Add(new InputNode(0)); // { InValue = 0 });
inputNodes1.Add(new InputNode(1)); // { InValue = 0 });
inputNodes1.Add(new InputNode(2)); // { InValue = 1 });
var bias = -2.0;
var hiddenNodes = new List <HiddenNode>()
{
new HiddenNode(0, sigFunction, weightAdjust, getRandom)
{
Bias = bias
},
new HiddenNode(1, sigFunction, weightAdjust, getRandom)
{
Bias = bias
},
new HiddenNode(2, sigFunction, weightAdjust, getRandom)
{
Bias = bias
}
};
foreach (var hidden in hiddenNodes)
{
hidden.AddInputNodes(inputNodes1);
}
var outnode = new OutputNode(0, step, weightAdjust, getRandom);
outnode.AddInputNodes(hiddenNodes);
//outnode.Bias = -2.0;
Debug.WriteLine("Node {0} weight:{1}", 0, inputNodes1[0].Weights[0]);
Debug.WriteLine("Node {0} weight:{1}", 1, inputNodes1[0].Weights[1]);
Debug.WriteLine("Node {0} weight:{1}", 0, hiddenNodes[0].Weights[0]);
Debug.WriteLine("Node {0} weight:{1}", 0, hiddenNodes[1].Weights[0]);
for (int x = 0; x < 100000; x++)
{
hiddenNodes.ForEach((h) =>
{
h.CalculateOutput();
});
outnode.SetInput(new double[] { 0.0, 0.0, 1.0 });
outnode.CalculateOutput();
outnode.AdjustWeights(0);
outnode.SetInput(new double[] { 1.0, 1.0, 1.0 });
outnode.CalculateOutput();
outnode.AdjustWeights(1);
outnode.SetInput(new double[] { 1.0, 0.0, 1.0 });
outnode.CalculateOutput();
outnode.AdjustWeights(1);
outnode.SetInput(new double[] { 0.0, 1.0, 1.0 });
outnode.CalculateOutput();
outnode.AdjustWeights(0);
}
Debug.WriteLine("Node {0} weight:{1}", 0, inputNodes1[0].Weights[0]);
Debug.WriteLine("Node {0} weight:{1}", 1, inputNodes1[0].Weights[1]);
Debug.WriteLine("Node {0} weight:{1}", 0, hiddenNodes[0].Weights[0]);
Debug.WriteLine("Node {0} weight:{1}", 0, hiddenNodes[1].Weights[0]);
outnode.SetInput(new double[] { 1.0, 0.0, 0.0 });
outnode.CalculateOutput();
var outp = outnode.Output;
Assert.IsTrue(outp == 1);
outnode.SetInput(new double[] { 0.0, 0.0, 0.0 });
outnode.CalculateOutput();
outp = outnode.Output;
Assert.IsTrue(outp == 0);
}
