public DataVector(VectorBatch batch)
: base(batch)
{
if (batch.Count != 1)
{
throw new ArgumentException("Can create a Vector only from a non-empty, singleton VectorBatch");
}
}
protected override VectorBatch _backPropagate(VectorBatch outputGradient)
{
VectorBatch inputGradient = _getInputGradient(outputGradient);
_updateWeights(outputGradient);
_updateBiases(outputGradient);
return(inputGradient);
}
protected override VectorBatch _backPropagate(VectorBatch 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.");
}
return(VectorBatch.ApplyFunction((x, y) => x * (1 - x) * y, _output, outputGradient));
}
protected override VectorBatch _trainingRun(VectorBatch input)
{
_input = input;
VectorBatch combination = _weights.ApplyForwards(input);
VectorBatch output = combination.AddToEachVector(_biases);
return(output);
}
protected override VectorBatch _backPropagate(VectorBatch outputGradient)
{
_activationGradient = outputGradient;
if (_neuralFunction != null)
{
_activationGradient = _neuralFunction.BackPropagate(outputGradient);
}
return(base._backPropagate(outputGradient));
}
protected override VectorBatch _trainingRun(VectorBatch input)
{
VectorBatch output = base._trainingRun(input);
if (_neuralFunction != null)
{
output = _neuralFunction.Run(output);
}
return(output);
}
protected override VectorBatch _run(VectorBatch inputbatch)
{
_input = inputbatch;
if (_neuralFunction != null)
{
_output = VectorBatch.ApplyFunction(x => _neuralFunction(x), _input);
}
else
{
_output = inputbatch;
}
return(_output);
}
protected override VectorBatch _backPropagate(VectorBatch outputGradient)
{
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);
}
VectorBatch derivative = VectorBatch.ApplyFunction((x, y) => _neuralFunctionDerivative(x, y), _input, _output);
VectorBatch result = VectorBatch.ApplyFunction((x, y) => x * y, derivative, outputGradient);
return(result);
}
protected override VectorBatch _run(VectorBatch inputbatch)
{
if (inputbatch == null || inputbatch.Dimension != NumberOfInputs)
{
throw new ArgumentException("input may not be null and must have dimension equal to the number of units.");
}
_input = inputbatch;
VectorBatch result = inputbatch.SubractVectorMaxima();
result = VectorBatch.ApplyFunction(x => Math.Exp(x), result);
result = result.DivideByComponentSums();
_output = result;
return(_output);
}
protected override VectorBatch _getInputGradient(VectorBatch outputGradient)
{
return(_weights.ApplyBackwards(outputGradient));
}
public SoftMaxUnit(int numberofunits)
: base(numberofunits, numberofunits)
{
_input = new DataVector(numberofunits);
_output = new DataVector(numberofunits);
}
public VectorBatch Run(VectorBatch input)
{
return(_run(input));
}
public VectorBatch ApplyBackwards(VectorBatch vector)
{
return(new VectorBatch((Matrix.Multiply(vector, this))));
}
public VectorBatch ApplyForwards(VectorBatch vector)
{
return(new VectorBatch((Matrix.MultiplyByTranspose(vector, this))));
}
protected override void _updateBiases(VectorBatch outputGradient)
{
BiasesVector biasesGradient = new BiasesVector(_activationGradient.SumColumnsAsMatrix());
_biases = _biases.Add(Strategy.BiasesUpdate(biasesGradient));
}
public VectorBatch Subtract(VectorBatch other)
{
return(new VectorBatch(SubtractMatrices(this, other)));
}
protected abstract VectorBatch _trainingRun(VectorBatch input);
protected abstract void _updateWeights(VectorBatch outputGradient);
public VectorBatch BackPropagate(VectorBatch outputGradient)
{
return(_backPropagate(outputGradient));
}
protected abstract VectorBatch _run(VectorBatch input);
protected override void _updateWeights(VectorBatch outputGradient)
{
WeightsMatrix weightsGradient = WeightsMatrix.FromVectorBatchPair(_input, _activationGradient);
_weights = _weights.Add(Strategy.WeightsUpdate(weightsGradient));
}
protected override VectorBatch _run(VectorBatch input)
{
_input = input;
return(_trainingRun(_input));
}
public static WeightsMatrix FromVectorBatchPair(VectorBatch first, VectorBatch second)
{
return(new WeightsMatrix(Matrix.TransposeAndMultiplyBy(second, first)));
}
protected override VectorBatch _getInputGradient(VectorBatch outputGradient)
{
return(base._getInputGradient(_activationGradient));
}
protected abstract VectorBatch _backPropagate(VectorBatch outputGradient);
protected abstract VectorBatch _getInputGradient(VectorBatch outputGradient);
public static VectorBatch ApplyFunction(Func <double, double> fctn, VectorBatch batch)
{
return(new VectorBatch(Matrix.ApplyFunction(fctn, batch)));
}
protected abstract void _updateBiases(VectorBatch outputGradient);
public static VectorBatch ApplyFunction(Func <double, double, double> fctn, VectorBatch first, VectorBatch second)
{
return(new VectorBatch(Matrix.ApplyFunction(fctn, first, second)));
}
