protected override void Mutation() { do { outputNeuron = Network.GetRandomNeuron(); inputNeuron = Network.GetRandomNeuron(); } while ((inputNeuron == outputNeuron)); insertedNeuron = new Neuron(ActivationFunc); synapseToOutput = new Synapse(insertedNeuron) { Weight = NeuralHelper.GetRandomWeigth() }; outputNeuron.InputSynapses.Add(synapseToOutput); synapseToInput = new Synapse(inputNeuron) { Weight = NeuralHelper.GetRandomWeigth() }; insertedNeuron.InputSynapses.Add(synapseToInput); Network.Neurons.Add(insertedNeuron); Network.Synapses.Add(synapseToOutput); Network.Synapses.Add(synapseToInput); }
public void inscribeController(string controllerInput) { string[] controllerLines = controllerInput.Split('|'); string[] neuronLines = controllerLines[1].Split(':'); string[] synapseLines = controllerLines[2].Split(':'); string[] tempSynapseLine; hiddenNeurons.Clear(); // All hidden neurons are cleared with each inscription synapses.Clear(); netTag = controllerLines[0]; // Create new hidden neuron population to match the inscriber for (int i = 0; i < int.Parse(neuronLines[0]); i++) { hiddenNeurons.Add(new HiddenNeuron()); } List <Neuron> allNeurons = Tools.consolidateLists(new List <List <Neuron> > { sensorNeurons, effectorNeurons, hiddenNeurons }); // Clear Neuron Synapses (we need only clear the sensors and effectors as hidden was cleared) for (int i = 0; i < sensorNeurons.Count + effectorNeurons.Count; i++) { allNeurons[i].clearSynapses(); } // Create new synapses based on inscription controller for (int i = 0; i < synapseLines.Length; i++) { tempSynapseLine = synapseLines[i].Split('='); Synapse tempSyn = new Synapse(allNeurons[int.Parse(tempSynapseLine[1])], allNeurons[int.Parse(tempSynapseLine[2])], float.Parse(tempSynapseLine[0])); allNeurons[int.Parse(tempSynapseLine[1])].addSynapse(tempSyn); synapses.Add(tempSyn); } }
private void DisplaySynapseHitEffect(SynapseLocation synapseHitLocation) { Synapse synapseObject = this.allSynapses[synapseHitLocation]; switch (synapseObject.Mode) { case SynapseMode.OneTimePositive: this.DisplayOneTimePositiveHitEffect(synapseHitLocation); break; case SynapseMode.OneTimeNegative: this.DisplayOneTimeNegativeHitEffect(synapseHitLocation); break; case SynapseMode.Neutral: this.DisplayNeutralHitEffect(synapseHitLocation); break; case SynapseMode.RepetitivePositive: this.DisplayRepetitivePositiveHitEffect(synapseHitLocation); break; default: Debug.LogError("GameManager.DisplaySynapseHitEffect: Unknown synapse mode"); break; } }
/// <summary> /// Takes a neural net and creates new synapses for it /// </summary> /// <param name="net"></param> /// <returns></returns> public List <Synapse> CreateSynapses(NeuralNetwork net) { List <Synapse> result = new List <Synapse>(); var layers = net.GetLayers(); foreach (var layer in layers) { var currentLayerNeurons = net.GetAllNeuronsInLayer(layer); var nextLayerNeurons = net.GetAllNeuronsInNextLayer(layer); foreach (var currentLayerNeuron in currentLayerNeurons) { //Get the next layer foreach (var nextlayerNeuron in nextLayerNeurons) { //Create a synapse var synapse = new Synapse(currentLayerNeuron, nextlayerNeuron); //Randomize the weight synapse.Weight = GetRandomWeight(); result.Add(synapse); } } } return(result); }
/// <summary> /// Connect two neurons. /// This neuron is the output neuron of the connection. /// </summary> /// <param name="inputNeuron">Neuron that will be input neuron of the newly created connection. /// </param> public void AddInputNeuron(INeuron inputNeuron, double weight) { var synapse = new Synapse(inputNeuron, this, weight); Inputs.Add(synapse); inputNeuron.Outputs.Add(synapse); }
public Synapse cloneSynapse(List <Neuron> list, int pID, int cID) { Synapse s = new Synapse(id, list[pID], list[cID]); s.weight = weight; return(s); }
public EntitySpawnMutator(Synapse s) { foreach (var o in s.Options.Split(',')) { _options.Add(o); } }
private void pruneSynapse(Synapse synapseToBePruned) { // pruneSynapse ----- says on the tin synapseToBePruned.parent.connectedSynapses.Remove(synapseToBePruned); synapseToBePruned.child.connectedSynapses.Remove(synapseToBePruned); synapses.Remove(synapseToBePruned); }
/// <summary> /// Connect two neurons. /// This neuron is the output neuron of the connection. /// </summary> /// <param name="inputNeuron">Neuron that will be input neuron of the newly created connection. /// </param> public void AddInputNeuron(INeuron inputNeuron) { var synapse = new Synapse(inputNeuron, this); this.Inputs.Add(synapse); inputNeuron.Outputs.Add(synapse); }
protected override void Mutation() { randomSynapse = Network.GetRandomSynapse(); outputNeuron = Network.Neurons.Find(n => n.InputSynapses.Contains(randomSynapse)); inputConnection = randomSynapse._input; insertedNeuron = new Neuron(ActivationFunc); synapseToOutput = new Synapse(insertedNeuron) { Weight = NeuralHelper.GetRandomWeigth() }; outputNeuron.InputSynapses.Add(synapseToOutput); synapseToInput = new Synapse(inputConnection) { Weight = NeuralHelper.GetRandomWeigth() }; insertedNeuron.InputSynapses.Add(synapseToInput); outputNeuron.InputSynapses.Remove(randomSynapse); Network.Synapses.Remove(randomSynapse); Network.Neurons.Add(insertedNeuron); Network.Synapses.Add(synapseToOutput); Network.Synapses.Add(synapseToInput); }
private void UpdateSynapseWeight(Synapse synapse) { var prevDelta = synapse.WeightDelta; synapse.WeightDelta = learningRate * (synapse.OutputNeuron.ErrorGradient * synapse.InputNeuron.Output); synapse.Weight = synapse.Weight + synapse.WeightDelta + (momentum * prevDelta); }
private void ProcessSynapse(SimulationModel model, Synapse synapse, string actionName, Action <RegionModel, NeuronModel, RegionModel, NeuronModel> action) { if (!CheckSameRegion(synapse)) { return; } RegionModel fromRegion; RegionModel toRegion; if (!model.Regions.TryGetModel(synapse.From.Region, out fromRegion) || !model.Regions.TryGetModel(synapse.To.Region, out toRegion)) { string missingRegion = fromRegion == null ? "Source" : "Target"; LogSynapseNotProcessed(synapse, actionName, $"{missingRegion} region not found"); return; } NeuronModel fromNeuron; NeuronModel toNeuron; // These are synapses that outside of the region of interest, they are skipped. if (!fromRegion.Neurons.TryGetModel(synapse.From.Neuron, out fromNeuron) || !toRegion.Neurons.TryGetModel(synapse.To.Neuron, out toNeuron)) { return; } action(fromRegion, fromNeuron, toRegion, toNeuron); }
private ISynapse[] CreateSynapses(int[] layers, int synapsesCount, double learningRate) { var synapseIndex = 0; var firstNeuronInLayer = 0; var synapses = new ISynapse[synapsesCount]; for (var i = 0; i < layers.Length - 1; i++) { var prevLayerBegin = firstNeuronInLayer; var nextLayerBegin = firstNeuronInLayer + layers[i]; for (var j = prevLayerBegin; j < prevLayerBegin + layers[i]; j++) { for (var k = nextLayerBegin; k < nextLayerBegin + layers[i + 1]; k++) { synapses[synapseIndex] = new Synapse { P = _neurons[j], Q = _neurons[k], N = learningRate, W = _generator.Get(), }; synapseIndex++; } } firstNeuronInLayer += layers[i]; } return(synapses); }
public void AddOutputNeuron(INeuron neuron) { var synapse = new Synapse(this, neuron); Outputs.Add(synapse); neuron.Inputs.Add(synapse); }
public float GetWeightChange(Synapse synapse) { ArrayList homePreStat = synapse.PreNeuron.GetStatistics(preNeuronStatisticsKey).GetData(); ArrayList homePostStat = synapse.PostNeuron.GetStatistics(postNeuronStatisticsKey).GetData(); float div = (float)homePostStat[0]; float k = (float)homePostStat[1]; float dw = 0; if (stdp.IsDopaminergic) { dw = stdp.GetWeightChangeWithDopamine(synapse, (List <int>)homePreStat[2], (List <int>)homePostStat[2]); } else { dw = stdp.GetWeightChange(synapse, (List <int>)homePreStat[2], (List <int>)homePostStat[2]); } float hm = (alpha * synapse.Weight * div + dw) * k; //Dynamic reduction //alpha *= 0.99f; //Console.WriteLine(); //Console.WriteLine("Alpha = " + alpha); //Console.WriteLine(); if (Network.Time < averagingWindow) { return(dw); } return(hm); }
public void TestColumnSerialize() { //Thread.Sleep(5000); //Pool pool = new Pool(10, 10); Cell cell = new Cell(); DistalDendrite dist = new DistalDendrite(cell, 0, 0, 0, 0.5, 10); dist.Synapses.Add(new Synapse(cell, null, 0, 0.5)); Synapse syn = new Synapse(cell, dist, 0, 0); var dict = UnitTestHelpers.GetMemory(); Column col = new Column(10, 0, 0.01, 10); col.ProximalDendrite = new ProximalDendrite(0, 0.01, 10); col.ProximalDendrite.Synapses = new List <Synapse>(); col.ProximalDendrite.Synapses.Add(syn); dict.ColumnDictionary.Add(0, col); var serCol = AkkaSb.Net.ActorReference.SerializeMsg(col); Assert.IsTrue(dict.ColumnDictionary[0].ProximalDendrite.Synapses[0].Segment != null); }
public Matrix <double> ProcessInputs(Matrix <double> neuronValues, Matrix <double> nextLayerNeuronBias = null) //If nextLayerNeuonBias = null then it is not using bias!! { //Batch Processing if (Synapse == null) { throw new Exception("No synapse matrix to process layer. Do not process the output layer!"); } if (neuronValues.ColumnCount != NeuronCount) { throw new Exception("Incorrect number of neuron values as input for layer " + Name); } //Matrix representation calculations for improved efficiency Matrix <double> weights; Matrix <double> input; if (nextLayerNeuronBias != null) { weights = Synapse.Stack(nextLayerNeuronBias); //Add Row of biases input = neuronValues.Append(Matrix <double> .Build.Dense(neuronValues.RowCount, 1, 1)); //Add Column of 1s } else { weights = Synapse; input = neuronValues; } var layerOutput = input * weights; Matrix <double> nextLayerNeuronValues = activationFunction(layerOutput); return(nextLayerNeuronValues); }
public ISynapse CreateSynapse(INeuron source, INeuron target) { var synapse = new Synapse(source, target); AddSynapse(synapse); return(synapse); }
public void testNoChangeToNonSelectedMatchingSegmentsInBurstingColumn() { TemporalMemory tm = new TemporalMemory(); Connections cn = new Connections(); Parameters p = GetDefaultParameters(null, Parameters.KEY.PERMANENCE_DECREMENT, 0.08); p.Apply(cn); TemporalMemory.Init(cn); int[] previousActiveColumns = { 0 }; int[] activeColumns = { 1 }; Cell[] previousActiveCells = { cn.GetCell(0), cn.GetCell(1), cn.GetCell(2), cn.GetCell(3) }; Cell[] burstingCells = { cn.GetCell(4), cn.GetCell(5) }; DistalDendrite selectedMatchingSegment = cn.CreateSegment(burstingCells[0]); cn.CreateSynapse(selectedMatchingSegment, previousActiveCells[0], 0.3); cn.CreateSynapse(selectedMatchingSegment, previousActiveCells[1], 0.3); cn.CreateSynapse(selectedMatchingSegment, previousActiveCells[2], 0.3); cn.CreateSynapse(selectedMatchingSegment, cn.GetCell(81), 0.3); DistalDendrite otherMatchingSegment = cn.CreateSegment(burstingCells[1]); Synapse as1 = cn.CreateSynapse(otherMatchingSegment, previousActiveCells[0], 0.3); Synapse as2 = cn.CreateSynapse(otherMatchingSegment, previousActiveCells[1], 0.3); Synapse is1 = cn.CreateSynapse(otherMatchingSegment, cn.GetCell(81), 0.3); tm.Compute(cn, previousActiveColumns, true); tm.Compute(cn, activeColumns, true); Assert.AreEqual(0.3, as1.GetPermanence(), 0.01); Assert.AreEqual(0.3, as2.GetPermanence(), 0.01); Assert.AreEqual(0.3, is1.GetPermanence(), 0.01); }
private void AddSynapse(string word, string nextWord) { word = TrimPunctuation(word); nextWord = TrimPunctuation(nextWord); wordDictionary.TryGetValue(word, out int wordNeuronID); if (wordNeuronID == 0) // if there is no neuron for the word, add one { wordDictionary.Add(word, nextFreeNeuron); wordNeuronID = nextFreeNeuron++; na.GetNeuronAt(wordNeuronID).Label = word; //useful someday } wordDictionary.TryGetValue(nextWord, out int nextWordNeuronID); if (nextWordNeuronID == 0) // if there is no neuron for the word, add one { wordDictionary.Add(nextWord, nextFreeNeuron); nextWordNeuronID = nextFreeNeuron++; na.GetNeuronAt(nextWordNeuronID).Label = nextWord; //useful someday } Neuron n = na.GetNeuronAt(wordNeuronID); Neuron nNext = na.GetNeuronAt(nextWordNeuronID); Synapse s = n.FindSynapse(nNext.id); float weight = .1f; if (s != null) { weight += .1f; } n.AddSynapse(nNext.id, weight); }
public void TestReinforcedSelectedMatchingSegmentInBurstingColumn() { TemporalMemory tm = new TemporalMemory(); Connections cn = new Connections(); Parameters p = getDefaultParameters(null, KEY.PERMANENCE_DECREMENT, 0.08); p.apply(cn); tm.Init(cn); int[] previousActiveColumns = { 0 }; int[] activeColumns = { 1 }; Cell[] previousActiveCells = { cn.GetCell(0), cn.GetCell(1), cn.GetCell(2), cn.GetCell(3) }; Cell[] burstingCells = { cn.GetCell(4), cn.GetCell(5) }; DistalDendrite activeSegment = cn.CreateDistalSegment(burstingCells[0]); Synapse as1 = cn.CreateSynapse(activeSegment, previousActiveCells[0], 0.3); Synapse as2 = cn.CreateSynapse(activeSegment, previousActiveCells[0], 0.3); Synapse as3 = cn.CreateSynapse(activeSegment, previousActiveCells[0], 0.3); Synapse is1 = cn.CreateSynapse(activeSegment, cn.GetCell(81), 0.3); DistalDendrite otherMatchingSegment = cn.CreateDistalSegment(burstingCells[1]); cn.CreateSynapse(otherMatchingSegment, previousActiveCells[0], 0.3); cn.CreateSynapse(otherMatchingSegment, previousActiveCells[1], 0.3); cn.CreateSynapse(otherMatchingSegment, cn.GetCell(81), 0.3); tm.Compute(previousActiveColumns, true); tm.Compute(activeColumns, true); Assert.AreEqual(0.4, as1.Permanence, 0.01); Assert.AreEqual(0.4, as2.Permanence, 0.01); Assert.AreEqual(0.4, as3.Permanence, 0.01); Assert.AreEqual(0.22, is1.Permanence, 0.001); }
private void ProcessSynapseHit(SynapseLocation synapseHitLocation) { Synapse synapseObject = this.allSynapses[synapseHitLocation]; synapseObject.HitSynapse(); switch (synapseObject.Mode) { case SynapseMode.OneTimePositive: this.ProcessOneTimePositiveHit(synapseHitLocation); break; case SynapseMode.OneTimeNegative: this.ProcessOneTimeNegativeHit(synapseHitLocation); break; case SynapseMode.Neutral: this.ProcessNeutralHit(synapseHitLocation); break; case SynapseMode.RepetitivePositive: this.ProcessRepetitivePositiveHit(synapseHitLocation); break; default: Debug.LogError("GameManager.ProcessSynapseHit: Unknown synapse mode"); break; } }
public Neuron(double value = 0, Synapse connection = null) { this.Value = value; this.Connection = connection; this.Dendrites = dendrites; this.Bias = bias; }
public void AddSynapse(string name, Synapse synapse) { SynapseNames.Add(name); synapses.Add(synapse); Weights.Add(new List <float>()); Weights.Last().Add(synapse.Weight); }
/// <summary> /// Connect two neurons. /// This neuron is the input neuron of the connection. /// </summary> /// <param name="outputNeuron">Neuron that will be output neuron of the newly created connection. /// </param> public void AddOutputNeuron(INeuron outputNeuron) { var synapse = new Synapse(this, outputNeuron); this.Outputs.Add(synapse); outputNeuron.Inputs.Add(synapse); }
protected override void Mutation() { synapse = Network.GetRandomSynapse(); oldDestination = synapse._input; synapse._input = Network.GetRandomNode(); }
public override void Connect(Layer inLayer) { if (inLayer.Shape != InputShape) { throw new ShapeMismatchException(nameof(inLayer)); } ShapedArray <Neuron> padded = Padder.PadArray(inLayer.Neurons.ToShape(Shape), Paddings, () => new Neuron() { OutVal = PadVal }); var inConnections = new ShapedArray <List <Synapse> >(PaddedShape, () => new List <Synapse>()); IndexGen.ByStrides(PaddedShape, Strides, KernelShape).ForEach((idxKernel, i) => { Neuron outN = base.Neurons[i]; outN.InSynapses = IndexGen.ByStart(KernelShape, Array <int> .FromRef(idxKernel)).Select((idx, j) => { var S = new Synapse(padded[idx], outN); inConnections[idx].Add(S); return(S); }); }); padded.ForEach((N, i) => N.OutSynapses = Array <Synapse> .FromRef(inConnections[i].ToArray())); }
public void testReinforcedCorrectlyActiveSegments() { TemporalMemory tm = new TemporalMemory(); Connections cn = new Connections(); Parameters p = GetDefaultParameters(null, Parameters.KEY.INITIAL_PERMANENCE, 0.2); p = GetDefaultParameters(p, Parameters.KEY.MAX_NEW_SYNAPSE_COUNT, 4); p = GetDefaultParameters(p, Parameters.KEY.PERMANENCE_DECREMENT, 0.08); p = GetDefaultParameters(p, Parameters.KEY.PREDICTED_SEGMENT_DECREMENT, 0.02); p.Apply(cn); TemporalMemory.Init(cn); int[] previousActiveColumns = { 0 }; int[] activeColumns = { 1 }; Cell[] previousActiveCells = { cn.GetCell(0), cn.GetCell(1), cn.GetCell(2), cn.GetCell(3) }; Cell activeCell = cn.GetCell(5); DistalDendrite activeSegment = cn.CreateSegment(activeCell); Synapse as1 = cn.CreateSynapse(activeSegment, previousActiveCells[0], 0.5); Synapse as2 = cn.CreateSynapse(activeSegment, previousActiveCells[1], 0.5); Synapse as3 = cn.CreateSynapse(activeSegment, previousActiveCells[2], 0.5); Synapse is1 = cn.CreateSynapse(activeSegment, cn.GetCell(81), 0.5); tm.Compute(cn, previousActiveColumns, true); tm.Compute(cn, activeColumns, true); Assert.AreEqual(0.6, as1.GetPermanence(), 0.1); Assert.AreEqual(0.6, as2.GetPermanence(), 0.1); Assert.AreEqual(0.6, as3.GetPermanence(), 0.1); Assert.AreEqual(0.42, is1.GetPermanence(), 0.001); }
private static void ProcessSynapseState(Synapse synapse) { if (synapse == null) { SendOutput($"Unknown synapse {Params[1]}"); return; } switch (Params[0]) { case "state": break; case "toggle": synapse.IsEnabled = !synapse.IsEnabled; break; case "disable": synapse.IsEnabled = false; break; case "enable": synapse.IsEnabled = true; break; } SendOutput($"Synapse {synapse.Name} is {(synapse.IsEnabled ? "Enabled" : "Disabled")}"); }
public void Constructor_WeightPassed_WeightCreated() { var fromNeruonMock = new Mock <INeuron>(); var toNeruonMock = new Mock <INeuron>(); var connection = new Synapse(fromNeruonMock.Object, toNeruonMock.Object, 111); Assert.AreEqual(111, connection.Weight); }
private void _compute(NeuralOutputHolder holder, NeuralLayer layer, NVector input, Synapse source) { PreProcessLayer(layer, input, source); foreach (var synapse in layer.OutputSynapses) { if (!holder.Results.ContainsKey(synapse)) { var nextLayer = synapse.OutputLayer; var pattern = synapse.Compute(input); pattern = synapse.OutputLayer.Compute(pattern); synapse.OutputLayer.Process(pattern); holder.Results[synapse] = input; _compute(holder, synapse.OutputLayer, pattern, synapse); if (nextLayer == Network.OutputLayer) { holder.Output = pattern; } } } }
/// <summary>Can be overridden by subclasses. Usually used to implement recurrent layers.</summary> public virtual void PreProcessLayer(NeuralLayer layer, NVector input, Synapse source) { }
protected virtual double Sum(Synapse[] synapses) { double sum = Bias; foreach (var syn in synapses) sum += syn.Output; return sum; }
protected override double Sum(Synapse[] synapses) { return Input = base.Sum(synapses); }
protected sealed override bool GenerateOutput(Synapse[] inputConnections, Synapse[] outputConnections, out double output) { output = Activation(Sum(inputConnections)); return true; }
public Synapse SynapseTo(Neuron neuron) { Synapse synapse = new Synapse(this, neuron); this.outputSynapses.Add(synapse); neuron.inputSynapses.Add(synapse); return synapse; }