public HierarchicalNetwork(params int[] neuronsCount) { ncnt = new int[neuronsCount.Length]; Array.Copy(neuronsCount, ncnt, ncnt.Length); // neurons neurons = new Neuron[ncnt.Length][]; for (var i = 0; i < ncnt.Length; ++i) { neurons[i] = new Neuron[ncnt[i]]; for (var j = 0; j < ncnt[i]; ++j) { if (i == 0) { neurons[i][j] = new Neuron(1); neurons[i][j].SetWeights(1.0); neurons[i][j].Threshold = 0.0; neurons[i][j].TransferFunction = (v => v); } else { neurons[i][j] = new Neuron(ncnt[i - 1]); for (var k = 0; k < ncnt[i - 1]; ++k) { neurons[i][j].Inputs[k] = neurons[i - 1][k]; neurons[i][j].Weights[k] = rnd.NextDouble() / 10.0; } neurons[i][j].Threshold = rnd.NextDouble() / 10.0; } } } }
public Neuron(Neuron neuron) { m_inputsCount = neuron.m_inputsCount; m_weights = (double[])neuron.m_weights.Clone(); m_function = neuron.m_function; m_threshold = neuron.m_threshold; }
public NetworkLayer(int inputSize, int neuronCount) { layer = new Neuron[neuronCount]; Random ran = new Random(); for (int x = 0; x < layer.Length; x++) layer[x] = new Neuron(inputSize+1, ran); }
public Layer(Layer layer) { m_inputsCount = layer.m_inputsCount; m_neuronsCount = layer.m_neuronsCount; m_function = layer.m_function; m_neurons = new Neuron[m_neuronsCount]; for (int i = 0; i < m_neuronsCount; i++) m_neurons[i] = new Neuron(layer[i]); m_output = (double[])layer.m_output.Clone(); }
public Layer(int inputsCount, int neuronsCount, double[] thresholds, IActivationFunction function) { m_inputsCount = inputsCount; m_neuronsCount = neuronsCount; m_function = function; m_neurons = new Neuron[neuronsCount]; for (int i = 0; i < neuronsCount; i++) m_neurons[i] = new Neuron(m_inputsCount, m_function, thresholds[i]); m_output = new double[neuronsCount]; }
public Neuron(Neuron neuron) : this() { InnovationNo = neuron.InnovationNo; Bias = neuron.Bias; }
public Synapse(Neuron input, Neuron output, int innovationno) : this(input, output) { InnovationNo = innovationno; }
public Synapse(Neuron toneuron, double data) // input synapse for first layer { ToNeuron = toneuron; PushedData = data; Weight = 1; }
public void Activate(Neuron Activator,float ActivationAmount) { curActivationAmount = input; // if (curActivationAmount >= Threshold||isOutput) // { //Console.WriteLine(curActivationAmount); float x = isOutput ? Threshold : Threshold; Fire(((float)(1/(1+Math.Pow(Math.E,(-curActivationAmount-x)/1f)))) * 2 - 1); //curActivationAmount = 0; // } // else // { //Fire(0.5f); // Console.WriteLine("Value " + curActivationAmount + " didn't make it against "+Threshold); // } if (NeuronRecieveEvent != null) { NeuronRecieveEvent(this, input); } //NeuronRecieveEvent(this, ActivationAmount); // Console.WriteLine("Neuron Triggered: " + ActivationAmount); }
public Dentrite(Neuron input, Neuron output) { weight = random.NextDouble() * (0.5 - (-0.5)) + (-0.5); inputNeuron = input; outputNeuron = output; }
public Synapse(Neuron toNeuron, double output) { _toNeuron = toNeuron; OutputVal = output; Weight = 1; }
public Connection(Neuron prevNeuron, Neuron nextNeuron) { prevLayerNeuron = prevNeuron; nextLayerNeuron = nextNeuron; weight = 2.0f * Random.NextDouble() - 1.0f; }
public double ErrorFeedback(Neuron input) { Weight w = _weights.Find(delegate(Weight t) { return(t.Input == input); }); return(_error * Derivative * w.Value); }
public Connection(Neuron neuron, float weight) //Konstruktor { this.neuron = neuron; this.weight = weight; }
public void AddOutputNeuron(Neuron outputneuron) { Synapse synapse = new Synapse(this, outputneuron); Outputs.Add(synapse); outputneuron.Inputs.Add(synapse); }
public Link(Neuron neuron) { Neuron = neuron; }
// main function of the neural network to train and store the outputs using backprop & feedforward public void compute() { int epoch = 0; // used for iterating through tests N times // hidden layer of neurons Neuron hidden1 = new Neuron(); Neuron hidden2 = new Neuron(); Neuron hidden3 = new Neuron(); Neuron hidden4 = new Neuron(); //output neuron Neuron output = new Neuron(); output.randomizeWeights(); hidden1.randomizeWeights(); hidden2.randomizeWeights(); hidden3.randomizeWeights(); hidden4.randomizeWeights(); //double errorRate = 1; //output.error = 1; while (epoch < 100) // iterate based on the output error OR use epochs > 100 for reliable numbers { //errorRate = 0; epoch++; for (int i = 0; i < 16; i++) { // set each neurons inputs to the training set hidden1.inputs = new double[] { inputs[i, 0], inputs[i, 1], inputs[i, 2], inputs[i, 3] }; hidden2.inputs = new double[] { inputs[i, 0], inputs[i, 1], inputs[i, 2], inputs[i, 3] }; hidden3.inputs = new double[] { inputs[i, 0], inputs[i, 1], inputs[i, 2], inputs[i, 3] }; hidden4.inputs = new double[] { inputs[i, 0], inputs[i, 1], inputs[i, 2], inputs[i, 3] }; // set the outputnode inputs to the results of the 4 neurons sigmoid transfer output.inputs = new double[] { hidden1.output(), hidden2.output(), hidden3.output(), hidden4.output() }; // display the training set and the "output of the output" neuron // we set the output nodes inputs above, and now we're using those inputs * weights + bias formula in the output function textBox1.AppendText(inputs[i, 0] + " " + inputs[i, 1] + " " + inputs[i, 2] + " " + inputs[i, 3] + " = " + output.output() + "\r\n"); outputResults.Add(output.output()); neuronOutputs.Add(new double[] { hidden1.output(), hidden2.output(), hidden3.output(), hidden4.output() }); // calculate the error output.error = sigmoid.derivative(output.output()) * (answers[i] - output.output()); output.tweakWeights(); // calculate the neurons error rates based on their individual outputs * the error rate of the output neuron * the weights of the output neuron // the sigmoid deriv is used for adjusting the weights in order to reduce the error rate of each neuron hidden1.error = sigmoid.derivative(hidden1.output()) * output.error * output.weights[0]; hidden2.error = sigmoid.derivative(hidden2.output()) * output.error * output.weights[1]; hidden3.error = sigmoid.derivative(hidden3.output()) * output.error * output.weights[2]; hidden4.error = sigmoid.derivative(hidden4.output()) * output.error * output.weights[3]; // the line below is irrelevant since our sigmoid function takes care of the error rate //double error = answers[i] - output.output(); // tweak the neurons weights using the error rates by adding the error rate * input value to the weights hidden1.tweakWeights(); hidden2.tweakWeights(); hidden3.tweakWeights(); hidden4.tweakWeights(); //errorRate += Math.Abs(error); } } }
public Network Copy() { /* Needed for breadth first graph traversal */ Queue <Neuron> queue = new Queue <Neuron>(); Dictionary <Neuron, Neuron> map = new Dictionary <Neuron, Neuron> (); /* Cloned network */ Network copyNetwork = new Network(); /* We will start traversal from the actuator */ Neuron originalActuator = this.actuator; Neuron copyActuator = new Neuron(); copyNetwork.SetActuator(copyActuator); /* Add the first in line for processing, the original actuator */ queue.Enqueue(originalActuator); map.Add(originalActuator, copyActuator); List <Neuron> copyioNodes = new List <Neuron>(); List <Neuron> copyiNodes = new List <Neuron>(); List <Neuron> copyoNodes = new List <Neuron>(); List <Neuron> copySensors = new List <Neuron>(); foreach (Neuron s in sensors) { Neuron temp = new Neuron(); map.Add(s, temp); queue.Enqueue(s); copySensors.Add(temp); copyiNodes.Add(temp); } while (queue.Count > 0) { /* Node we are currently processing */ Neuron originalNode = queue.Dequeue(); List <Synapse> inputSynapses = originalNode.GetInputs(); List <Synapse> outputSynapses = originalNode.GetOutputs(); /* Clone of the original node that is being processed */ Neuron copyNode = map[originalNode]; foreach (Synapse inputSynapse in inputSynapses) { /* Get the real input node */ Neuron inputOriginal = inputSynapse.GetSource(); /* If the copy of the inputOriginal doesn't exist, create it. Otherwise just connect */ if (!map.ContainsKey(inputOriginal)) { Neuron inputCopy = new Neuron(); copyioNodes.Add(inputCopy); Synapse synapseCopy = new Synapse(inputCopy, copyNode, inputSynapse.getWeight()); inputCopy.AddOutput(synapseCopy); copyNode.AddInput(synapseCopy); map.Add(inputOriginal, inputCopy); queue.Enqueue(inputOriginal); } else { /* Get the copy of the real node since it exists */ Neuron inputCopy = map[inputOriginal]; bool alreadyExists = false; foreach (Synapse n in inputCopy.GetOutputs()) { if (n.GetSource().Equals(inputCopy) && n.GetDestination().Equals(copyNode)) { alreadyExists = true; break; } } if (!alreadyExists) { /* Create input synapse between cloned nodes */ Synapse copySynapse = new Synapse(inputCopy, copyNode, inputSynapse.getWeight()); copyNode.AddInput(copySynapse); inputCopy.AddOutput(copySynapse); } } } foreach (Synapse outputSynapse in outputSynapses) { /* Get the real output node */ Neuron outputOriginal = outputSynapse.GetDestination(); /* If the copy of the outputOriginal doesn't exist, create it. Otherwise just connect */ if (!map.ContainsKey(outputOriginal)) { Neuron outputCopy = new Neuron(); copyioNodes.Add(outputCopy); Synapse syn = new Synapse(copyNode, outputCopy, outputSynapse.getWeight()); copyNode.AddOutput(syn); outputCopy.AddInput(syn); map.Add(outputOriginal, outputCopy); queue.Enqueue(outputOriginal); } else { /* Get the copy of the real node since it exists */ Neuron outputCopy = map[outputOriginal]; bool alreadyExists = false; foreach (Synapse n in outputCopy.GetInputs()) { if (n.GetSource().Equals(copyNode) && n.GetDestination().Equals(outputCopy)) { alreadyExists = true; break; } } if (!alreadyExists) { /* Create output synapse between cloned nodes */ Synapse copySynapse = new Synapse(copyNode, outputCopy, outputSynapse.getWeight()); copyNode.AddOutput(copySynapse); outputCopy.AddInput(copySynapse); } } } } /* Set newly created sensors */ copyNetwork.SetSensors(copySensors); /* Within cloned network, remove sensors from ioNodes, add to iNodes*/ //for (Neuron copySensor : copySensors) { // copyioNodes.remove(copySensor); // copyiNodes.add(copySensor); // } /* Add all nodes (except sensors, and actuator) to iNodes and oNodes */ foreach (Neuron ioNode in copyioNodes) { copyiNodes.Add(ioNode); copyoNodes.Add(ioNode); } /* Add actuator to oNodes */ copyoNodes.Add(copyActuator); copyNetwork.SetInputNodes(copyiNodes); copyNetwork.SetOutputNodes(copyoNodes); copyNetwork.SetInputOutputNodes(copyioNodes); // Crap code ahead ================================ WOO HOO WATCH ME ========================================== // TODO: Erase this souts once we create a few working networks // System.out.println("Length of ioNodes " + copyioNodes.size()); // System.out.println("Length of iNodes " + copyiNodes.size() + " it should be ioNodes + 3"); // System.out.println("Length of oNodes " + copyoNodes.size() + " it should be ioNodes + 1"); // System.out.println(copyNetwork.actuator); // System.out.println(copyActuator); // System.out.println(copyActuator.weightedSum); // for (Neuron n : copyNetwork.iNodes) // { // System.out.println(n.weightedSum); // System.out.println(n.getOutputs()); // System.out.println(n.getInputs()); // } // Crap code finished ============================= WOO HOO WATCH ME ========================================== return(copyNetwork); }
public void AddNeuron(Neuron neuron) => Neurons.Add(neuron);
public void SetActuator(Neuron actuator) { this.actuator = actuator; this.oNodes.Add(actuator); }
public static Network Decode(string input) { List<Neuron> outputs = new List<Neuron>(outputNeuronAmount); int outputoffset = (int)(inputNeuronAmount * HiddenLayerNeuronAmount+ (HiddenLayerNeuronAmount*2)*HiddenLayerNeuronAmount*(HiddenLayerAmount-1)+(HiddenLayerNeuronAmount+outputNeuronAmount)*HiddenLayerNeuronAmount) * 4 ; char[] c = input.ToCharArray(); BitArray bits = new BitArray(input.Length); for(int i = 0; i < input.Length; i++) { bits[i] = c[i] == '1' ? true : false; } byte[] bytes = ConvertToByte(bits); for (int i = 0; i < outputNeuronAmount; i++) { //Console.WriteLine(bytes.Length+" " + (outputoffset)); float threshold = BitConverter.ToSingle(new byte[] { bytes[outputoffset + i * 4], bytes[outputoffset + i * 4 + 1], bytes[outputoffset + i * 4 + 2], bytes[outputoffset + i * 4 + 3] },0) + (new Random().Next(-10, 10) / 100.0f); outputs.Add(new Neuron(threshold)); //Console.WriteLine(threshold); } int hiddenlayer3output = (int)(inputNeuronAmount * HiddenLayerNeuronAmount + (HiddenLayerNeuronAmount * 2) * HiddenLayerNeuronAmount * (HiddenLayerAmount-1)) * 4; List<Neuron> HiddenLayer3 = new List<Neuron>(HiddenLayerNeuronAmount); List<List<float>> recursiveList = new List<List<float>>(HiddenLayerNeuronAmount); for (int i = 0; i < HiddenLayerNeuronAmount; i++) { float threshold = BitConverter.ToSingle(new byte[] { bytes[hiddenlayer3output + i * (HiddenLayerNeuronAmount + outputNeuronAmount) * HiddenLayerNeuronAmount + (HiddenLayerNeuronAmount + outputNeuronAmount) * HiddenLayerNeuronAmount-4], bytes[hiddenlayer3output + i * (HiddenLayerNeuronAmount + outputNeuronAmount) * HiddenLayerNeuronAmount + (HiddenLayerNeuronAmount + outputNeuronAmount) * HiddenLayerNeuronAmount - 3], bytes[hiddenlayer3output + i * (HiddenLayerNeuronAmount + outputNeuronAmount) * HiddenLayerNeuronAmount + (HiddenLayerNeuronAmount + outputNeuronAmount) * HiddenLayerNeuronAmount - 2], bytes[hiddenlayer3output + i * (HiddenLayerNeuronAmount + outputNeuronAmount) * HiddenLayerNeuronAmount + (HiddenLayerNeuronAmount + outputNeuronAmount) * HiddenLayerNeuronAmount - 1] }, 0) + (new Random().Next(-10, 10) / 100.0f); //Console.WriteLine(threshold>1||threshold<-1); float[] NextLayerWeights = new float[outputNeuronAmount]; for (int x = 0; x < outputNeuronAmount; x++) { NextLayerWeights[x] = BitConverter.ToSingle(new byte[] { bytes[hiddenlayer3output + i * (HiddenLayerNeuronAmount + outputNeuronAmount) * HiddenLayerNeuronAmount + x * 4], bytes[hiddenlayer3output +i* (HiddenLayerNeuronAmount + outputNeuronAmount) * HiddenLayerNeuronAmount+ x * 4 + 1], bytes[hiddenlayer3output +i* (HiddenLayerNeuronAmount + outputNeuronAmount) * HiddenLayerNeuronAmount+ x * 4 + 2], bytes[hiddenlayer3output +i* (HiddenLayerNeuronAmount + outputNeuronAmount) * HiddenLayerNeuronAmount+ x * 4 + 3] }, 0) + (new Random().Next(-10, 10) / 100.0f); //Console.WriteLine(NextLayerWeights[x]); } int hiddenlayerrecursiveoffset = hiddenlayer3output + outputNeuronAmount * 4; float[] RecursiveWeights = new float[HiddenLayerNeuronAmount - 1]; for (int x = 0; x < HiddenLayerNeuronAmount - 1; x++) { RecursiveWeights[x] = BitConverter.ToSingle(new byte[] { bytes[hiddenlayer3output + i * (HiddenLayerNeuronAmount + outputNeuronAmount) * HiddenLayerNeuronAmount + x * 4 + outputNeuronAmount*4], bytes[hiddenlayer3output + i * (HiddenLayerNeuronAmount + outputNeuronAmount) * HiddenLayerNeuronAmount + x * 4 + outputNeuronAmount * 4+1], bytes[hiddenlayer3output + i * (HiddenLayerNeuronAmount + outputNeuronAmount) * HiddenLayerNeuronAmount + x * 4 + outputNeuronAmount * 4+2], bytes[hiddenlayer3output + i * (HiddenLayerNeuronAmount + outputNeuronAmount) * HiddenLayerNeuronAmount + x * 4 + (outputNeuronAmount) * 4+3] }, 0) + (new Random().Next(-10, 10) / 100.0f); } Neuron n = new Neuron(threshold, outputs); for (int x = 0; x < n.TargetSynapses.Count; x++) { n.TargetSynapses[x].Weight = NextLayerWeights[x]; } recursiveList.Add(RecursiveWeights.ToList()); HiddenLayer3.Add(n); } int q = 0; int z = 0; foreach (Neuron n in HiddenLayer3) { n.RecursiveSynapses = new List<Synapse>(); foreach (Neuron r in HiddenLayer3) { if (n == r) continue; //Console.WriteLine(HiddenLayer3.Count); n.RecursiveSynapses.Add(new Synapse(n, r, recursiveList[q][z])); z++; } z = 0; q++; } hiddenlayer3output = (int)(inputNeuronAmount * HiddenLayerNeuronAmount + (HiddenLayerNeuronAmount * 2) * HiddenLayerNeuronAmount * (HiddenLayerAmount - 2)) * 4; List<Neuron> HiddenLayer2 = new List<Neuron>(HiddenLayerNeuronAmount); recursiveList = new List<List<float>>(HiddenLayerNeuronAmount); for (int i = 0; i < HiddenLayerNeuronAmount; i++) { float threshold = BitConverter.ToSingle(new byte[] { bytes[hiddenlayer3output + i * 32 + 28], bytes[hiddenlayer3output + i * 32 + 29], bytes[hiddenlayer3output + i * 32 + 30], bytes[hiddenlayer3output + i * 32 + 31] }, 0) + (new Random().Next(-10, 10) / 100.0f); //Console.WriteLine(threshold); //Console.WriteLine(threshold > 1 || threshold < -1); float[] NextLayerWeights = new float[HiddenLayerNeuronAmount]; for (int x = 0; x < HiddenLayerNeuronAmount; x++) { NextLayerWeights[x] = BitConverter.ToSingle(new byte[] { bytes[hiddenlayer3output + i * HiddenLayerNeuronAmount*2*HiddenLayerNeuronAmount + x * 4], bytes[hiddenlayer3output + x * 4 + 1], bytes[hiddenlayer3output + i * HiddenLayerNeuronAmount * 2 * HiddenLayerNeuronAmount + x * 4 + 2], bytes[hiddenlayer3output + i * HiddenLayerNeuronAmount * 2 * HiddenLayerNeuronAmount + x * 4 + 3] }, 0) + (new Random().Next(-10, 10) / 100.0f); // Console.WriteLine(NextLayerWeights[x]); } int hiddenlayerrecursiveoffset = hiddenlayer3output + HiddenLayerNeuronAmount * 4; float[] RecursiveWeights = new float[HiddenLayerNeuronAmount - 1]; for (int x = 0; x < HiddenLayerNeuronAmount - 1; x++) { RecursiveWeights[x] = BitConverter.ToSingle(new byte[] { bytes[hiddenlayer3output + i * 32 + x * 4 + 16], bytes[hiddenlayer3output + i * 32 + x * 4 + 17], bytes[hiddenlayer3output + i * 32 + x * 4 + 18], bytes[hiddenlayer3output + i * 32 + x * 4 + 19] }, 0) + (new Random().Next(-10, 10) / 100.0f); } Neuron n = new Neuron(threshold, HiddenLayer3); for (int x = 0; x < n.TargetSynapses.Count; x++) { n.TargetSynapses[x].Weight = NextLayerWeights[x]; } recursiveList.Add(RecursiveWeights.ToList()); HiddenLayer2.Add(n); } q = 0; z = 0; foreach (Neuron n in HiddenLayer2) { n.RecursiveSynapses = new List<Synapse>(); foreach (Neuron r in HiddenLayer2) { if (n == r) continue; //Console.WriteLine(HiddenLayer3.Count); n.RecursiveSynapses.Add(new Synapse(n, r, recursiveList[q][z])); z++; } z = 0; q++; } hiddenlayer3output = (int)(inputNeuronAmount * HiddenLayerNeuronAmount + (HiddenLayerNeuronAmount * 2) * HiddenLayerNeuronAmount * (HiddenLayerAmount - 3)) * 4; List<Neuron> HiddenLayer1 = new List<Neuron>(HiddenLayerNeuronAmount); recursiveList = new List<List<float>>(HiddenLayerNeuronAmount); for (int i = 0; i < HiddenLayerNeuronAmount; i++) { float threshold = BitConverter.ToSingle(new byte[] { bytes[hiddenlayer3output + i * 32 + 28], bytes[hiddenlayer3output + i * 32 + 29], bytes[hiddenlayer3output + i * 32 + 30], bytes[hiddenlayer3output + i * 32 + 31] }, 0) + (new Random().Next(-10, 10) / 100.0f); //Console.WriteLine(threshold); //Console.WriteLine(threshold > 1 || threshold < -1); float[] NextLayerWeights = new float[HiddenLayerNeuronAmount]; for (int x = 0; x < HiddenLayerNeuronAmount; x++) { NextLayerWeights[x] = BitConverter.ToSingle(new byte[] { bytes[hiddenlayer3output +i * HiddenLayerNeuronAmount * 2 * HiddenLayerNeuronAmount + x * 4], bytes[hiddenlayer3output + i * HiddenLayerNeuronAmount * 2 * HiddenLayerNeuronAmount + x * 4 + 1], bytes[hiddenlayer3output + i * HiddenLayerNeuronAmount * 2 * HiddenLayerNeuronAmount + x * 4 + 2], bytes[hiddenlayer3output + i * HiddenLayerNeuronAmount * 2 * HiddenLayerNeuronAmount + x * 4 + 3] }, 0) + (new Random().Next(-10, 10) / 100.0f); //Console.WriteLine(NextLayerWeights[x]); } int hiddenlayerrecursiveoffset = hiddenlayer3output + HiddenLayerNeuronAmount * 4; float[] RecursiveWeights = new float[HiddenLayerNeuronAmount - 1]; for (int x = 0; x < HiddenLayerNeuronAmount - 1; x++) { RecursiveWeights[x] = BitConverter.ToSingle(new byte[] { bytes[hiddenlayer3output + i * 32 + x * 4 + 16], bytes[hiddenlayer3output + i * 32 + x * 4 + 17], bytes[hiddenlayer3output + i * 32 + x * 4 + 18], bytes[hiddenlayer3output + i * 32 + x * 4 + 19] }, 0) + (new Random().Next(-10, 10) / 100.0f); } Neuron n = new Neuron(threshold, HiddenLayer2); for (int x = 0; x < n.TargetSynapses.Count; x++) { n.TargetSynapses[x].Weight = NextLayerWeights[x]; } recursiveList.Add(RecursiveWeights.ToList()); HiddenLayer1.Add(n); } q = 0; z = 0; foreach (Neuron n in HiddenLayer1) { n.RecursiveSynapses = new List<Synapse>(); foreach (Neuron r in HiddenLayer1) { if (n == r) continue; //Console.WriteLine(HiddenLayer3.Count); n.RecursiveSynapses.Add(new Synapse(n, r, recursiveList[q][z])); z++; } z = 0; q++; } hiddenlayer3output = 0;//(int)(inputNeuronAmount * HiddenLayerNeuronAmount + (HiddenLayerNeuronAmount * 2) * HiddenLayerNeuronAmount * (HiddenLayerAmount - 2)) * 4; List<Neuron> inputs = new List<Neuron>(inputNeuronAmount); //recursiveList = new List<List<float>>(HiddenLayerNeuronAmount); for (int i = 0; i < inputNeuronAmount; i++) { float threshold = BitConverter.ToSingle(new byte[] { bytes[hiddenlayer3output + i * 32 + 28], bytes[hiddenlayer3output + i * 32 + 29], bytes[hiddenlayer3output + i * 32 + 30], bytes[hiddenlayer3output + i * 32 + 31] }, 0) + (new Random().Next(-10, 10) / 100.0f) + (new Random().Next(-10, 10) / 100.0f); //Console.WriteLine(threshold); //Console.WriteLine(threshold > 1 || threshold < -1); float[] NextLayerWeights = new float[HiddenLayerNeuronAmount]; for (int x = 0; x < HiddenLayerNeuronAmount; x++) { NextLayerWeights[x] = BitConverter.ToSingle(new byte[] { bytes[hiddenlayer3output + i * inputNeuronAmount * HiddenLayerNeuronAmount + x * 4], bytes[hiddenlayer3output + i * inputNeuronAmount * HiddenLayerNeuronAmount + x * 4 + 1], bytes[hiddenlayer3output + i * inputNeuronAmount * HiddenLayerNeuronAmount + x * 4 + 2], bytes[hiddenlayer3output + i * inputNeuronAmount * HiddenLayerNeuronAmount + x * 4 + 3] }, 0)+ (new Random().Next(-10, 10) / 100.0f) + (new Random().Next(-10, 10) / 100.0f); //Console.WriteLine(NextLayerWeights[x]); } //int hiddenlayerrecursiveoffset = hiddenlayer3output + outputNeuronAmount * 4; //float[] RecursiveWeights = new float[outputNeuronAmount - 1]; //for (int x = 0; x < outputNeuronAmount - 1; x++) //{ // RecursiveWeights[x] = BitConverter.ToSingle(new byte[] { bytes[hiddenlayer3output + i * 32 + x * 4 + 16], bytes[hiddenlayer3output + i * 32 + x * 4 + 17], bytes[hiddenlayer3output + i * 32 + x * 4 + 18], bytes[hiddenlayer3output + i * 32 + x * 4 + 19] }, 0); //} Neuron n = new Neuron(threshold, HiddenLayer1); for (int x = 0; x < n.TargetSynapses.Count; x++) { n.TargetSynapses[x].Weight = NextLayerWeights[x]; } //recursiveList.Add(RecursiveWeights.ToList()); inputs.Add(n); } return new Network(inputNeuronAmount, HiddenLayerNeuronAmount, outputNeuronAmount) { Inputs = inputs, Outputs = outputs, HiddenLayer1 = HiddenLayer1, HiddenLayer2 = HiddenLayer2, HiddenLayer3 =HiddenLayer3 }; }
public void addInput(Neuron n) { new Axon(n, this); }
public Synapse(Neuron inputNeuron, Neuron outputNeuron) { InputNeuron = inputNeuron; OutputNeuron = outputNeuron; Weight = NeuralNet.GetRandom(); }
public void OnHiddenFire(Neuron Activator, float amount) { Console.WriteLine( " of hidden layer was activated with " + amount + " " + Activator.Threshold); }
public Synapse(Neuron fromneuron, Neuron toneuron) // standard synapse { FromNeuron = fromneuron; ToNeuron = toneuron; Weight = tmp.NextDouble() - 0.5; }
public Perceptron(List <Tuple <double[], double> > data) { PerceptronNeuron = new Neuron(); TrainingSet = data; PerceptronNeuron.Initialize(data[0].Item1.Length); }
public void OnOutputFire(Neuron Activator,float amount) { if (!isTraining) { //Console.WriteLine(Outputs.IndexOf(Activator) + " of output layer was activated with " + amount + " " + Activator.Threshold); } }
public Synapse(Neuron fromneuron, Neuron toneuron) // standard synapse { FromNeuron = fromneuron; ToNeuron = toneuron; Weight = rnd.NextDouble() * (MaxInitWeight - MinInitWeight) + MinInitWeight; SynapsesCount += 1; }
public void OnInputFire(Neuron Activator, float amount) { Console.WriteLine(Inputs.IndexOf(Activator) + " of input layer was activated with " + amount + " " + Activator.Threshold); }
static void Main(string[] args) { int[] H = { 1, 0, 1, 1, 1, 1, 1, 0, 1 }; int[] answers = { 1, 0, 1, 1, 1, 1, 1, 0, 1 }; int[,] letters = { { 0, 1, 0, 0, 1, 0, 0, 1, 0 }, { 1, 1, 1, 1, 0, 1, 1, 1, 1 },{ 1, 0, 1, 1, 1, 1, 1, 0, 1 }, { 1, 0, 1, 1, 0, 1, 1, 1, 1 }, { 1, 1, 1, 1, 0, 1, 1, 0, 1 } }; Neuron neuron = new Neuron(H, answers); neuron.Train(); Console.WriteLine("It took {0} generations", neuron.generation); Console.ReadKey(); Console.Clear(); for (int i = 0; i < letters.GetLength(0); i++) { int[] array = new int[letters.GetLength(1)]; for (int j = 0; j < letters.GetLength(1); j++) { array[j] = letters[i, j]; } bool isH = neuron.Test(array); if (isH) { Console.WriteLine("It is a H!"); } } Console.ReadKey(); }