public virtual void SsqHessianByRef(Vector <double> x, Matrix <double> output)
{
if (output.RowCount != this.ParameterDimension || output.ColumnCount != this.ParameterDimension)
{
throw new ArgumentException($"Output matrix must match parameter dimension of function; expected {this.ParameterDimension}x{this.ParameterDimension}, got {output.RowCount}x{output.ColumnCount}.");
}
for (int ii = 0; ii < this.ParameterDimension; ++ii)
{
for (int jj = 0; jj < this.ParameterDimension; ++jj)
{
output[ii, jj] = 0.0;
}
}
var tmp_grad = new LinearAlgebra.Double.DenseVector(this.ParameterDimension);
var tmp_hess = new LinearAlgebra.Double.DenseMatrix(this.ParameterDimension, this.ParameterDimension);
double tmp_value = 0.0;
for (int ii = 0; ii < this.ItemDimension; ++ii)
{
tmp_value = this.ItemValue(x, ii);
this.ItemGradientByRef(x, ii, tmp_grad);
this.ItemHessianByRef(x, ii, tmp_hess);
for (int jj = 0; jj < this.ParameterDimension; ++jj)
{
for (int kk = 0; kk < this.ParameterDimension; ++kk)
{
var increment = 2 * (tmp_value * tmp_hess[jj, kk] + tmp_grad[jj] * tmp_grad[kk]);
output[jj, kk] += increment;
}
}
}
}
public virtual Vector <double> ItemGradient(Vector <double> x, int itemIndex)
{
var output = new LinearAlgebra.Double.DenseVector(this.ParameterDimension);
this.ItemGradientByRef(x, itemIndex, output);
return(output);
}
public virtual Vector <double> SsqGradient(Vector <double> x)
{
var output = new LinearAlgebra.Double.DenseVector(this.ParameterDimension);
this.SsqGradientByRef(x, output);
return(output);
}
/// <summary>
/// Construct an initial simplex, given starting guesses for the constants, and
/// initial step sizes for each dimension
/// </summary>
/// <param name="simplexConstants"></param>
/// <returns></returns>
static Vector <double>[] InitializeVertices(SimplexConstant[] simplexConstants)
{
int numDimensions = simplexConstants.Length;
Vector <double>[] vertices = new Vector <double> [numDimensions + 1];
// define one point of the simplex as the given initial guesses
var p0 = new LinearAlgebra.Double.DenseVector(numDimensions);
for (int i = 0; i < numDimensions; i++)
{
p0[i] = simplexConstants[i].Value;
}
// now fill in the vertices, creating the additional points as:
// P(i) = P(0) + Scale(i) * UnitVector(i)
vertices[0] = p0;
for (int i = 0; i < numDimensions; i++)
{
double scale = simplexConstants[i].InitialPerturbation;
Vector <double> unitVector = new LinearAlgebra.Double.DenseVector(numDimensions);
unitVector[i] = 1;
vertices[i + 1] = p0.Add(unitVector.Multiply(scale));
}
return(vertices);
}
/// <summary>
/// Finds the minimum of the objective function without an initial perturbation, the default values used
/// by fminsearch() in Matlab are used instead
/// http://se.mathworks.com/help/matlab/math/optimizing-nonlinear-functions.html#bsgpq6p-11
/// </summary>
/// <param name="objectiveFunction">The objective function, no gradient or hessian needed</param>
/// <param name="initialGuess">The initial guess</param>
/// <returns>The minimum point</returns>
public static MinimizationResult Minimum(IObjectiveFunction objectiveFunction, Vector <double> initialGuess, double convergenceTolerance = 1e-8, int maximumIterations = 1000)
{
var initalPertubation = new LinearAlgebra.Double.DenseVector(initialGuess.Count);
for (int i = 0; i < initialGuess.Count; i++)
{
initalPertubation[i] = initialGuess[i] == 0.0 ? 0.00025 : initialGuess[i] * 0.05;
}
return(Minimum(objectiveFunction, initialGuess, initalPertubation, convergenceTolerance, maximumIterations));
}
/// <summary>
/// Finds the minimum of the objective function without an intial pertubation, the default values used
/// by fminsearch() in Matlab are used instead
/// http://se.mathworks.com/help/matlab/math/optimizing-nonlinear-functions.html#bsgpq6p-11
/// </summary>
/// <param name="objectiveFunction">The objective function, no gradient or hessian needed</param>
/// <param name="initialGuess">The intial guess</param>
/// <returns>The minimum point</returns>
public MinimizationResult FindMinimum(IObjectiveFunction objectiveFunction, Vector <double> initialGuess)
{
var initalPertubation = new LinearAlgebra.Double.DenseVector(initialGuess.Count);
for (int i = 0; i < initialGuess.Count; i++)
{
initalPertubation[i] = initialGuess[i] == 0.0 ? 0.00025 : initialGuess[i] * 0.05;
}
return(FindMinimum(objectiveFunction, initialGuess, initalPertubation));
}
/// <summary>
/// Compute the centroid of all points except the worst
/// </summary>
/// <param name="vertices"></param>
/// <param name="errorProfile"></param>
/// <returns></returns>
static Vector <double> ComputeCentroid(Vector <double>[] vertices, ErrorProfile errorProfile)
{
int numVertices = vertices.Length;
// find the centroid of all points except the worst one
Vector <double> centroid = new LinearAlgebra.Double.DenseVector(numVertices - 1);
for (int i = 0; i < numVertices; i++)
{
if (i != errorProfile.HighestIndex)
{
centroid = centroid.Add(vertices[i]);
}
}
return(centroid.Multiply(1.0d / (numVertices - 1)));
}
public virtual void SsqGradientByRef(Vector <double> x, Vector <double> output)
{
if (output.Count != this.ParameterDimension)
{
throw new ArgumentException($"Output vector must match parameter dimension of function; expected {this.ParameterDimension}, got {output.Count}.");
}
for (int jj = 0; jj < this.ParameterDimension; ++jj)
{
output[jj] = 0.0;
}
var tmp_grad = new LinearAlgebra.Double.DenseVector(this.ParameterDimension);
double tmp_value = 0.0;
for (int ii = 0; ii < this.ItemDimension; ++ii)
{
tmp_value = this.ItemValue(x, ii);
this.ItemGradientByRef(x, ii, tmp_grad);
for (int jj = 0; jj < this.ParameterDimension; ++jj)
{
output[jj] += 2 * tmp_value * tmp_grad[jj];
}
}
}
