public override NetworkVector Gradient(NetworkVector target, NetworkVector vector) { return(NetworkVector.ApplyFunctionComponentWise( target, vector, (x, y) => 1 / y )); }
public NetworkVector InputGradient(NetworkVector outputgradient, NetworkVector output) { if (outputgradient == null || outputgradient.Dimension != NumberOfOutputs) { throw new ArgumentException("outputgradient may not be null and must have dimension equal to the number of units."); } return(NetworkVector.ApplyFunctionComponentWise(output, outputgradient, (x, y) => x * (1 - x) * y)); }
public override void BackPropagate(NetworkVector outputgradient) { if (outputgradient == null || outputgradient.Dimension != NumberOfOutputs) { throw new ArgumentException("outputgradient may not be null and must have dimension equal to NumberOfNeurons."); } _inputGradient = NetworkVector.ApplyFunctionComponentWise(_inputs, _outputs, (x, y) => _neuralFunctionDerivative(x, y)); }
public override double Cost(NetworkVector target, NetworkVector vector) { return (NetworkVector.ApplyFunctionComponentWise( target, vector, (x, y) => Math.Log(y) * x ).SumValues() / vector.Dimension); }
public override double Cost(NetworkVector target, NetworkVector vector) { return (NetworkVector.ApplyFunctionComponentWise( target, vector, (x, y) => (x - y) * (x - y) ).SumValues() / 2); }
public override void BackPropagate(NetworkVector outputgradient) { if (outputgradient == null || outputgradient.Dimension != NumberOfOutputs) { throw new ArgumentException("outputgradient may not be null and must have dimension equal to the number of units."); } _inputGradient = NetworkVector.ApplyFunctionComponentWise(_outputs, outputgradient, (x, y) => x * (1 - x) * y); }
public override void Run(NetworkVector inputvalues) { _inputs = inputvalues; if (_neuralFunction != null) { _outputs = NetworkVector.ApplyFunctionComponentWise(_inputs, x => _neuralFunction(x)); } else { _outputs = _inputs.Copy(); } }
public override void Run(NetworkVector inputvalues) { if (inputvalues == null || inputvalues.Dimension != _numberOfUnits) { throw new ArgumentException("inputvalues may not be null and must have dimension equal to the number of units."); } _inputs = inputvalues; _outputs = NetworkVector.ApplyFunctionComponentWise(_inputs, x => Math.Exp(x)); double sum = _outputs.SumValues(); _outputs = NetworkVector.ApplyFunctionComponentWise(_outputs, x => x / sum); }
public override NetworkVector Run(NetworkVector inputvalues) { if (inputvalues == null || inputvalues.Dimension != _numberOfUnits) { throw new ArgumentException("inputvalues may not be null and must have dimension equal to the number of units."); } double max = inputvalues.Vector.Max(); NetworkVector intermediateVector = NetworkVector.ApplyFunctionComponentWise(inputvalues.Copy(), x => Math.Exp(x - max)); double sum = intermediateVector.SumValues(); return(NetworkVector.ApplyFunctionComponentWise(intermediateVector, x => x / sum)); }
public override double Cost(NetworkVector target, NetworkVector vector) { _workingVector = NetworkVector.ApplyFunctionComponentWise(vector, x => Math.Exp(x)); _workingBatchMatrix = null; double sum = _workingVector.SumValues(); _workingVector = NetworkVector.ApplyFunctionComponentWise(_workingVector, x => x / sum); return (NetworkVector.ApplyFunctionComponentWise( target, _workingVector, (x, y) => Math.Log(y) * x ).SumValues() / vector.Dimension); }
public override NetworkVector Run(NetworkVector inputvalues) { _inputVector = inputvalues; _inputBatch = null; _outputBatch = null; if (_neuralFunction != null) { _outputVector = NetworkVector.ApplyFunctionComponentWise(inputvalues.Copy(), x => _neuralFunction(x)); } else { _outputVector = inputvalues.Copy(); } return(_outputVector); }
public NetworkVector InputGradient(NetworkVector outputgradient, NetworkVector input, NetworkVector output) { if (outputgradient == null || outputgradient.Dimension != NumberOfOutputs) { throw new ArgumentException("outputgradient may not be null and must have dimension equal to NumberOfNeurons."); } if (_neuralFunctionDerivative == null) { return(outputgradient.Copy()); } return(NetworkVector.ApplyFunctionComponentWise(_inputVector, _outputVector, (x, y) => _neuralFunctionDerivative(x, y))); //NetworkVector derivative = NetworkVector.ApplyFunctionComponentWise(_inputVector, _outputVector, (x, y) => _neuralFunctionDerivative(x, y)); //NetworkVector result = NetworkVector.ApplyFunctionComponentWise(derivative, outputgradient, (x, y) => x * y); //return result; }
protected double _errorFunction(NetworkVector result, NetworkVector expected) { NetworkVector _getSquaredErrors = NetworkVector.ApplyFunctionComponentWise(result, expected, (x, y) => (x - y) * (x - y)); return(_getSquaredErrors.SumValues() / 2); }