/// <summary> /// This method implements weights update procedure for the single neuron /// </summary> /// <param name="neuron">neuron to update weights for</param> protected override void UpdateNeuronWeights(Neuron neuron) { double output = neuron.Output; foreach (Connection connection in neuron.InputConnections) { double input = connection.Input; double weight = connection.ConnectionWeight.Value; double deltaWeight = this.LearningRate * output * (input - weight); connection.ConnectionWeight.Inc(deltaWeight); } }
/// <summary> /// This method implements weights update procedure for the single neuron /// </summary> /// <param name="neuron">neuron to update weights</param> protected virtual void UpdateNeuronWeights(Neuron neuron) { // get the error for specified neuron double neuronError = neuron.Error; // iterate through all neuron's input connections foreach (Connection connection in neuron.InputConnections) { // get the input from current connection double input = connection.Input; // calculate the weight change double deltaWeight = this.LearningRate * neuronError * input; // apply the weight change connection.ConnectionWeight.Inc(deltaWeight); } }
/// <summary> /// This method implements weights update procedure for the single neuron /// In addition to weights change in LMS it applies change to neuron's threshold /// </summary> /// <param name="neuron">neuron to update weights</param> protected override void UpdateNeuronWeights(Neuron neuron) { // adjust the input connection weights with method from superclass base.UpdateNeuronWeights(neuron); // and adjust the neurons threshold ThresholdNeuron thresholdNeuron = (ThresholdNeuron)neuron; // get neurons error double neuronError = thresholdNeuron.Error; // get the neurons threshold double thresh = thresholdNeuron.Thresh; // calculate new threshold value thresh = thresh - this.LearningRate * neuronError; // apply the new threshold thresholdNeuron.Thresh = thresh; }
/// <summary> /// This method implements weights update procedure for the single neuron /// </summary> /// <param name="neuron">neuron to update weights</param> protected override void UpdateNeuronWeights(Neuron neuron) { double output = neuron.Output; foreach (Connection connection in neuron.InputConnections) { double input = connection.Input; if (((input > 0) && (output > 0)) || ((input <= 0) && (output <= 0))) { connection.ConnectionWeight.Inc(this.LearningRate); } else { connection.ConnectionWeight.Dec(this.LearningRate); } } }
/// <summary> /// This method implements weights update procedure for the single neuron /// for the backpropagation with momentum factor /// </summary> /// <param name="neuron">neuron to update weights</param> protected override void UpdateNeuronWeights(Neuron neuron) { foreach (Connection connection in neuron.InputConnections) { double input = connection.Input; if (input == 0) { continue; } double neuronError = neuron.Error; Weight weight = connection.ConnectionWeight; double currentWeighValue = weight.Value; double previousWeightValue = weight.PreviousValue; double deltaWeight = this.LearningRate * neuronError * input + Momentum * (currentWeighValue - previousWeightValue); weight.PreviousValue = currentWeighValue; weight.Inc(deltaWeight); } }
/// <summary> /// Creates a new connection to specified neuron with specified weight object /// </summary> /// <param name="connectTo">neuron to connect to</param> /// <param name="weight">weight for this connection</param> public Connection(Neuron fromNeuron, Neuron toNeuron, double weightValue) { this.fromNeuron = fromNeuron; this.toNeuron = toNeuron; this.weight = new Weight(weightValue); }
/// <summary> /// Adds specified neuron to this layer /// </summary> /// <param name="neuron">neuron to add</param> public void AddNeuron(Neuron neuron) { neuron.ParentLayer = this; this.neurons.Add(neuron); }
/// <summary> /// Creates a new connection to specified neuron with specified weight object /// </summary> /// <param name="connectTo">neuron to connect to</param> /// <param name="weight">weight for this connection</param> public Connection(Neuron fromNeuron, Neuron toNeuron, Weight weight) { this.fromNeuron = fromNeuron; this.toNeuron = toNeuron; this.weight = weight; }
/// <summary> /// Creates a new connection between specified neurons with random weight value /// </summary> /// <param name="fromNeuron">neuron to connect</param> /// <param name="toNeuron">neuron to connect to</param> public Connection(Neuron fromNeuron, Neuron toNeuron) { this.fromNeuron = fromNeuron; this.toNeuron = toNeuron; this.weight = new Weight(); }
public override void AddInputConnection(Neuron fromNeuron, double weightVal) { }
/// <summary> /// Removes input connection which is connected to specified neuron /// </summary> /// <param name="fromNeuron">neuron which is connected as input</param> public virtual void RemoveInputConnectionFrom(Neuron fromNeuron) { foreach (Connection connection in this.inputConnections) { if (connection.FromNeuron == fromNeuron) { this.inputConnections.Remove(connection); return; } } }
/// <summary> /// Returns the index position in layer for the specified neuron /// </summary> /// <param name="neuron">neuron object</param> /// <returns>index position of specified neuron</returns> public int IndexOf(Neuron neuron) { return this.neurons.IndexOf(neuron); }
/// <summary> /// Sets (replace) the neuron at specified position in layer /// </summary> /// <param name="idx">index position to set/replace</param> /// <param name="neuron">new Neuron object to set</param> public void SetNeuron(int idx, Neuron neuron) { neuron.ParentLayer = this; this.neurons[idx] = neuron; }
private void AdjustCellWeights(Neuron cell, int r) { IEnumerator<Connection> i = cell.GetInputsEnumerator(); while (i.MoveNext()) { Connection conn = i.Current; double dWeight = (LearningRate / (r + 1)) * (conn.Input - conn.ConnectionWeight.Value); conn.ConnectionWeight.Inc(dWeight); }// while }
/// <summary> /// This method implements weights update procedure for the single neuron /// </summary> /// <param name="neuron">neuron to update weights</param> protected virtual void UpdateNeuronWeights(Neuron neuron) { double output = neuron.Output; foreach (Connection connection in neuron.InputConnections) { double input = connection.Input; double deltaWeight = input * output * this.LearningRate; connection.ConnectionWeight.Inc(deltaWeight); } }
public override void AddInputConnection(Neuron fromNeuron) { }
/// <summary> /// Creates an instance of delayed connection to cpecified neuron and /// with specified weight /// </summary> /// <param name="connectTo">neuron to connect ti</param> /// <param name="weightVal">weight value for the connection</param> /// <param name="delay">delay for the connection</param> public DelayedConnection(Neuron fromNeuron, Neuron toNeuron, double weightVal, int delay) : base(fromNeuron, toNeuron, weightVal) { this.delay = delay; }
/// <summary> /// Creates connection between two specified neurons /// </summary> /// <param name="from">output neuron</param> /// <param name="to">input neuron</param> /// <param name="weight">connection weight</param> public static void CreateConnection(Neuron from, Neuron to, Weight weight) { Connection connection = new Connection(from, to, weight); to.AddInputConnection(connection); }
public static void CreateConnection(Neuron from, Neuron to, double weightVal, int delay) { DelayedConnection connection = new DelayedConnection(from, to, weightVal, delay); to.AddInputConnection(connection); }
/// <summary> /// Creates connection with specified weight value between specified neurons /// </summary> /// <param name="fromNeuron">neuron to connect</param> /// <param name="toNeuron">neuron to connect to</param> /// <param name="weightVal">connection weight value</param> public void CreateConnection(Neuron fromNeuron, Neuron toNeuron, double weightVal) { Connection connection = new Connection(fromNeuron, toNeuron, weightVal); toNeuron.AddInputConnection(connection); }
// get unit with closetst weight vector private Neuron GetClosest() { IEnumerator<Neuron> i = this.NeuralNetwork.GetLayerAt(1) .GetNeuronsEnumerator(); Neuron winner = new Neuron(); double minOutput = 100; while (i.MoveNext()) { Neuron n = i.Current; double o = n.Output; if (o < minOutput) { minOutput = o; winner = n; } // if } // while return winner; }
/// <summary> /// This method implements weights update procedure for the single neuron /// </summary> /// <param name="neuron">neuron to update weights</param> /// <param name="desiredOutput"></param> protected void UpdateNeuronWeights(Neuron neuron, double desiredOutput) { foreach (Connection connection in neuron.InputConnections) { double input = connection.Input; double deltaWeight = input * desiredOutput * this.LearningRate; connection.ConnectionWeight.Inc(deltaWeight); } }
/// <summary> /// Adds specified neuron to this layer,at specified index position /// </summary> /// <param name="idx">neuron to add</param> /// <param name="neuron">index position at which neuron should be added</param> public void AddNeuron(int idx, Neuron neuron) { neuron.ParentLayer = this; this.neurons.Insert(idx, neuron); }
/// <summary> /// Adds input connection from specified neuron /// </summary> /// <param name="fromNeuron">neuron to connect from</param> public virtual void AddInputConnection(Neuron fromNeuron) { Connection connection = new Connection(fromNeuron, this); this.AddInputConnection(connection); }
/// <summary> /// Removes neuron from layer /// </summary> /// <param name="neuron">neuron to remove</param> public void RemoveNeuron(Neuron neuron) { this.neurons.Remove(neuron); }
/// <summary> /// Adds input connection with the given weight, from given neuron /// </summary> /// <param name="fromNeuron">neuron to connect from</param> /// <param name="weightVal">connection weight value</param> public virtual void AddInputConnection(Neuron fromNeuron, double weightVal) { Connection connection = new Connection(fromNeuron, this, weightVal); this.AddInputConnection(connection); }
/// <summary> /// Gets input connection from the specified neuron * @param fromNeuron /// neuron connected to this neuron as input /// </summary> /// <param name="fromNeuron"></param> /// <returns></returns> public virtual Connection GetConnectionFrom(Neuron fromNeuron) { foreach (Connection connection in this.inputConnections) { if (connection.FromNeuron == fromNeuron) return connection; } return null; }
/// <summary> /// Calculates and returns delta parameter (neuron error) for the specified /// neuron /// </summary> /// <param name="neuron">neuron to calculate error for</param> /// <returns>(neuron error) for the specified neuron</returns> private double CalculateDelta(Neuron neuron) { IList<Connection> connectedTo = ((Neuron)neuron).OutConnections; double delta_sum = 0d; foreach (Connection connection in connectedTo) { double d = connection.ToNeuron.Error * connection.ConnectionWeight.Value; delta_sum += d; // weighted sum from the next layer } // for TransferFunction transferFunction = neuron.TransferFunction; double netInput = neuron.NetInput; double f1 = transferFunction.CalculateDerivative(netInput); double delta = f1 * delta_sum; return delta; }