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);
}
