public override Neuron NameCopy() { WorkingNeuron clone = new WorkingNeuron(); clone.SetName(GetName()); return(clone); }
public void AddOutputNeuronAndMesh(WorkingNeuron neuron) { OutputNeurons.Add(neuron); foreach (WorkingNeuron wn in LastHiddenLayer) { neuron.AddNeuronConnection(new Connection(wn, 0)); } }
public void AddOutputNeuronAndMesh(WorkingNeuron neuron) { outputNeurons.Add(neuron); foreach (WorkingNeuron wn in hiddenNeurons) { neuron.AddNeuronConnection(new Connection(wn, 0)); } }
public void AddHiddenNeuron(WorkingNeuron neuron, int Layer) { if (Layer + 1 > 0 && Layer + 1 < neurons.Count) { neurons[Layer + 1].Add(neuron); } else { throw new ArgumentException("Layer needs to be within the hidden layer", "Layer"); } }
public Connection GetConnection(NetworkIndex index) { WorkingNeuron neuron = neurons[index.LayerIndex][index.NeuronIndex] as WorkingNeuron; if (neuron != null) { return(neuron.GetConnections()[index.ConnectionIndex]); } else { return(null); } }
private float GetStrongestLayerConnection(List <Neuron> layer) { float strongestConnection = 0; foreach (Neuron n in layer) { WorkingNeuron wn = (WorkingNeuron)n; float strongestNeuronConnection = Math.Abs(wn.GetStrongestConnection()); if (strongestNeuronConnection > strongestConnection) { strongestConnection = strongestNeuronConnection; } } return(strongestConnection); }
public void Deserialize(BinaryReader reader) { fullMeshGenerated = reader.ReadBoolean(); int inputCount = reader.ReadInt32(); for (int currentIndex = 0; currentIndex < inputCount; currentIndex++) { InputNeuron newNeuron = new InputNeuron(); newNeuron.Deserialize(reader); inputNeurons.Add(newNeuron); } int hiddenCount = reader.ReadInt32(); for (int currentIndex = 0; currentIndex < hiddenCount; currentIndex++) { WorkingNeuron newNeuron = new WorkingNeuron(); newNeuron.Deserialize(reader); hiddenNeurons.Add(newNeuron); int connectionCount = reader.ReadInt32(); for (int connectionIndex = 0; connectionIndex < connectionCount; connectionIndex++) { // Todo get rid of this covariance cast Connection connection = Connection.Deserialize(reader, inputNeurons.Cast <Neuron>()); newNeuron.AddNeuronConnection(connection); } } int outputCount = reader.ReadInt32(); for (int currentIndex = 0; currentIndex < outputCount; currentIndex++) { WorkingNeuron newNeuron = new WorkingNeuron(); newNeuron.Deserialize(reader); outputNeurons.Add(newNeuron); int connectionCount = reader.ReadInt32(); for (int connectionIndex = 0; connectionIndex < connectionCount; connectionIndex++) { // Todo get rid of this covariance cast Connection connection = Connection.Deserialize(reader, hiddenNeurons.Cast <Neuron>()); newNeuron.AddNeuronConnection(connection); } } Invalidate(); }
public void CreateHiddenLayer() { List <Neuron> newLayer = new List <Neuron>(); WorkingNeuron newNeuron = new WorkingNeuron(HiddenLayerCount + 2); int layerIndex = neurons.Count - 1; int prevLayerIndex = layerIndex - 1; int connectionCount = 0; while (prevLayerIndex >= 0) { if (layerIndex > 1 && prevLayerIndex == 0) { break; } float weight = 0.0f; if (connectionCount < LastHiddenLayer.Count && connectionCount < ((WorkingNeuron)LastHiddenLayer[connectionCount]).GetConnections().Count) { weight = ((WorkingNeuron)LastHiddenLayer[0]).GetConnections()[connectionCount].weight; } for (int prevNeuronIndex = connectionCount; prevNeuronIndex < neurons[prevLayerIndex].Count && ((!(prevLayerIndex == 0) || connectionCount < FirstHiddenLayer.Count) || layerIndex == 1); ++prevNeuronIndex) { newNeuron.AddNeuronConnection(neurons[prevLayerIndex][prevNeuronIndex], weight); connectionCount++; } --prevLayerIndex; } for (int outputIndex = 0; outputIndex < OutputNeurons.Count; outputIndex++) { WorkingNeuron currentOutputNeuron = OutputNeurons[outputIndex] as WorkingNeuron; for (int connectionIndex = 0; connectionIndex < currentOutputNeuron.GetConnections().Count; connectionIndex++) { if (currentOutputNeuron.GetConnections()[connectionIndex].entryNeuron == LastHiddenLayer[0]) { currentOutputNeuron.GetConnections()[connectionIndex].entryNeuron = newNeuron; } } } newLayer.Add(newNeuron); AddHiddenLayer(newLayer); }
public void RemoveHiddenLayer() { if (HiddenLayerCount > 1) { neurons.RemoveAt(neurons.Count - 2); for (int outNeuronIndex = 0; outNeuronIndex < OutputNeurons.Count; outNeuronIndex++) { WorkingNeuron outputNeuron = OutputNeurons[outNeuronIndex] as WorkingNeuron; if (outputNeuron.GetConnections().Count > LastHiddenLayer.Count) { outputNeuron.GetConnections().RemoveRange(LastHiddenLayer.Count, outputNeuron.GetConnections().Count - LastHiddenLayer.Count); } for (int connectionIndex = 0; connectionIndex < LastHiddenLayer.Count && connectionIndex < outputNeuron.GetConnections().Count; connectionIndex++) { outputNeuron.GetConnections()[connectionIndex].entryNeuron = LastHiddenLayer[connectionIndex]; } for (int connectionIndex = outputNeuron.GetConnections().Count; connectionIndex < LastHiddenLayer.Count; connectionIndex++) { outputNeuron.AddNeuronConnection(LastHiddenLayer[connectionIndex], (Simulation.RandomFloat() * 2 * -1)); } } } }
public static void Test() { Console.WriteLine("Begin NN Test!"); NeuronalNetwork nn = new NeuronalNetwork(); InputNeuron in1 = new InputNeuron(); InputNeuron in2 = new InputNeuron(); InputNeuron in3 = new InputNeuron(); WorkingNeuron out1 = new WorkingNeuron(0); WorkingNeuron out2 = new WorkingNeuron(0); WorkingNeuron out3 = new WorkingNeuron(0); nn.AddInputNeuron(in1); nn.AddInputNeuron(in2); nn.AddInputNeuron(in3); nn.GenerateHiddenNeurons(3, 1); nn.AddOutputNeuron(out1); nn.AddOutputNeuron(out2); nn.AddOutputNeuron(out3); nn.GenerateFullMesh(); nn.RandomizeAllWeights(); NeuronalNetwork nn2 = nn.CloneFullMesh(); for (int i = 0; i < 3; i++) { Debug.Assert(nn2.GetOutputNeuronFromIndex(i).GetValue() == nn.GetOutputNeuronFromIndex(i).GetValue()); } Console.WriteLine("NN Test success! <(^.^)>"); }
public void AddOutputNeuron(WorkingNeuron neuron) { outputNeurons.Add(neuron); }
public void AddHiddenNeuron(WorkingNeuron neuron) { hiddenNeurons.Add(neuron); }
public NeuronalNetwork CloneFullMesh() { if (!fullMeshGenerated) { throw new NeuronalNetworkNotFullmeshedException(); } NeuronalNetwork copy = new NeuronalNetwork(); Dictionary <Neuron, Neuron> oldToNewMap = new Dictionary <Neuron, Neuron>(); foreach (InputNeuron input in InputNeurons) { Neuron newNeuron = input.NameCopy(); oldToNewMap.Add(input, newNeuron); copy.AddInputNeuron((InputNeuron)newNeuron); } for (int layerIndex = 0; layerIndex < HiddenLayerCount; layerIndex++) { List <Neuron> newLayer = new List <Neuron>(); foreach (WorkingNeuron wn in neurons[layerIndex + 1]) { WorkingNeuron newNeuron = wn.NameCopy() as WorkingNeuron; oldToNewMap.Add(wn, newNeuron); newLayer.Add(newNeuron); foreach (Connection con in wn.GetConnections()) { newNeuron.AddNeuronConnection(oldToNewMap[con.entryNeuron], con.weight); } } copy.AddHiddenLayer(newLayer); } foreach (Neuron output in OutputNeurons) { WorkingNeuron newNeuron = output.NameCopy() as WorkingNeuron; copy.AddOutputNeuron(newNeuron); foreach (Connection con in (output as WorkingNeuron).GetConnections()) { newNeuron.AddNeuronConnection(oldToNewMap[con.entryNeuron], con.weight); } } copy.fullMeshGenerated = true; //copy.GenerateFullMesh(); //for (int layerIndex = 1; layerIndex < neurons.Count; layerIndex++) //{ // for (int neuronIndex = 0; neuronIndex < neurons[layerIndex].Count; neuronIndex++) // { // List<Connection> connectionsOriginal = ((WorkingNeuron)neurons[layerIndex][neuronIndex]).GetConnections(); // List<Connection> connectionsCopy = ((WorkingNeuron)copy.neurons[layerIndex][neuronIndex]).GetConnections(); // if (connectionsOriginal.Count != connectionsCopy.Count) // { // throw new NotSameAmountOfNeuronsException(); // } // for (int k = 0; k < connectionsOriginal.Count; k++) // { // connectionsCopy[k].weight = connectionsOriginal[k].weight; // } // } //} return(copy); }
public void RemoveOutputNeuron(WorkingNeuron neuron) { OutputNeurons.Remove(neuron); }