private INonlinearSolution _perform_itr(Rational var1_initial, Rational var2_initial, out int vidRow, out int vidVariable1, out int vidVariable2, out int vidVariable3, out int vidVariable4)
{
var solver = new NelderMeadSolver();
// By CQN solver convention, the vid for a row will always be 0
solver.AddRow(null, out vidRow);
solver.AddGoal(vidRow, 0, true);
// By CQN solver convention, first (and in this case only) variable always has the vid of 1
solver.AddVariable(null, out vidVariable1);
solver.AddVariable(null, out vidVariable2);
solver.AddVariable(null, out vidVariable3);
solver.AddVariable(null, out vidVariable4);
//solver.AddVariable(null, out vidVariable4);
Rational rVariable1 = var1_initial; solver.SetValue(vidVariable1, rVariable1);
Rational rVariable2 = var2_initial; solver.SetValue(vidVariable2, rVariable2);
//Rational rVariable2 = 0.0001; solver.SetValue(vidVariable2, rVariable2);
Rational rVariable3 = -0.2; solver.SetValue(vidVariable3, rVariable3);
Rational rVariable4 = 0.0; solver.SetValue(vidVariable4, rVariable4);
//Setting the evaluators
//solver.FunctionEvaluator = ((m,r,v,n) => { return Math.Pow(v[1] + _decay[1], 2); });
solver.FunctionEvaluator = this.SinxValue;
//solver.GradientEvaluator = SinxGradient;
var param = new NelderMeadSolverParams();
//param.MaximumSearchPoints = 10;
return(solver.Solve(param));
}
public void Config(NelderMeadSolver solver)
{
Configuration = new NelderMeadSolverParams();
Vector3D pos = FEstimatedPosition[0];
Vector3D min = pos - 0.5 * FTolerancePosition[0];
Vector3D max = pos + 0.5 * FTolerancePosition[0];
solver.SetBounds(1, min.x, max.x); // translation
solver.SetBounds(2, min.y, max.y);
solver.SetBounds(3, min.z, max.z);
for (int b = 4; b <= 6; b++)
{
solver.SetBounds(b, -0.5, 0.5); // rotation
}
solver.SetBounds(7, 0.05, 0.49); // fov
solver.SetBounds(8, -1, 1); // shift x
solver.SetBounds(9, -1, 1); // shift y
solver.SetValue(1, pos.x);
solver.SetValue(2, pos.y);
solver.SetValue(3, pos.z);
solver.SetValue(4, VMath.Map(VMath.Random.Next(100), 0, 100, -0.05, 0.05, TMapMode.Float));
solver.SetValue(5, VMath.Map(VMath.Random.Next(100), 0, 100, -0.05, 0.05, TMapMode.Float));
solver.SetValue(6, VMath.Map(VMath.Random.Next(100), 0, 100, -0.05, 0.05, TMapMode.Float));
solver.SetValue(7, 0.01);
solver.SetValue(8, 0.01);
solver.SetValue(9, 0.20);
}
public Doll EstimateSingleFrame(float w, float h, List <Keypoint> keypoints)
{
// Setup unknown variables' information
var estimationDoll = new Doll();
double[] unknowns;
double[] lowerLimits;
double[] upperLimits;
InitializeInputArrays(estimationDoll, out unknowns, out lowerLimits, out upperLimits);
double[] unknowns2 = new double[unknowns.Length];
// Call Nelder-mead solver in Microsoft.Solver.Foundation librabry
var solution = NelderMeadSolver.Solve(
(input) =>
{
ReflectDecisionsToDoll(input, estimationDoll);
estimationDoll.RenewAllPositions();
return(estimationDoll.CalculateResidualSum(w, h, (float)input[0], keypoints));
},
unknowns, lowerLimits, upperLimits);
Debug.WriteLine($"{solution.Result}");
Debug.WriteLine($"Solution = {solution.GetSolutionValue(0)}");
// Output
return(estimationDoll);
}
static void Main(string[] args)
{
double[] xInitial = new double[17] {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
};
double[] xLower = new double[17];
xLower.Populate(-5);
double[] xUpper = new double[17];
xUpper.Populate(5);
Matrix <Double> featureValues = DenseMatrix.OfArray(readFileIntoArray("testData"));
Vector <Double> trueValues = DenseVector.OfArray(readResultFileIntoArray("saveResult"));
var solution = NelderMeadSolver.Solve(x => MyCostFunctionMethod(x, featureValues, trueValues), xInitial, xLower, xUpper);
Console.WriteLine(solution.Result);
Console.WriteLine("solution = {0}", solution.GetSolutionValue(0));
for (int i = 0; i < 17; i++)
{
Console.WriteLine("x = {0}", solution.GetValue(i + 1));
}
Console.ReadKey();
}
static public void CalibrateToSwaptionValues(double[] inputVs
, SimpleBermudanSwaption[] europeanSwaptions
, double a, double init_sigma, out double sigma)
{
double[] xInitial = new double[] { init_sigma };
double[] xLower = new double[] { 1e-4 };
double[] xUpper = new double[] { 10 };
var solution = NelderMeadSolver.Solve(x =>
{
double J, J1 = 0D, J2 = 0D;
ComputeSwaptionCalibrationObjectives(false, inputVs, europeanSwaptions, a, x[0], out J, ref J1, ref J2);
Console.WriteLine("J={0},sigma={1}", J, x[0]);
return(J);
}, xInitial, xLower, xUpper);
sigma = solution.GetValue(1);
Console.WriteLine(solution.ToString());
}
public NelderMeadSolver Init()
{
var solver = new NelderMeadSolver();
int vidRow;
solver.AddRow(null, out vidRow);
solver.AddGoal(vidRow, 0, true);
int[] vidVariables = new int[dimensions];
for (int i = 0; i < dimensions; i++)
{
solver.AddVariable(null, out vidVariables[i]);
}
solver.FunctionEvaluator = DiffMapping;
Solvers.Clear();
Solvers.Add(solver);
return(solver);
}
/// <summary>
/// Execute optimisation of theta values based on training data.
/// </summary>
/// <param name="theta">Current values of theta.</param>
/// <param name="featureData">values of features.</param>
/// <param name="result">List of results based on feature values.</param>
/// <returns>Optimised values of theta</returns>
public static double[] Learn(double[] theta, double[,] featureData, double[] results)
{
double[] xInitial = theta;
double[] xLower = new double[theta.Length];
xLower.Populate(-5);
double[] xUpper = new double[theta.Length];
xUpper.Populate(5);
Matrix <Double> featureValues = DenseMatrix.OfArray(featureData);
Vector <Double> trueValues = DenseVector.OfArray(results);
var solution = NelderMeadSolver.Solve(x => CostFunction(x, featureValues, trueValues), xInitial, xLower, xUpper);
double[] optimisedTheta = new double[theta.Length];
//Console.WriteLine(solution.Result);
for (int i = 0; i < theta.Length; i++)
{
optimisedTheta[i] = solution.GetValue(i + 1);
}
return(optimisedTheta);
}
public double computeFWHM()
{
// these all need to be arrays, because that's the way the NelderMeadSolver works
double[] coeffs = new double[]
{ initialParams.intensity,
initialParams.wavelength,
initialParams.width,
initialParams.baseline };
////////////////////////////////////////////////////////////////////
// Bound the search
////////////////////////////////////////////////////////////////////
// TODO: add a method to override these from the caller
// TODO: find a way to "optimize" these based on initial conditions
// (an optimizer on the optimizer...yes I see the irony)
//
// (note we call the x-axis "wavelength," but sometimes it may be wavenumber or just pixel)
// int wl width base
double[] min = new double[] { 0, -1000, 0.1, 0 };
double[] max = new double[] { 65535, 3500, 50, 65535 };
// consider bounding things a bit closer than that, based on initial conditions:
// min[0] = coeffs[0] * 0.5; // intensity should be +/- 50% initial guess
// max[0] = coeffs[0] * 1.5;
// min[1] = coeffs[1] - 5 ; // wavelength shouldn't vary by more than 20,
// max[1] = coeffs[1] + 5 ; // whether wavelength, wavenumber or pixel
// max[3] = coeffs[0]; // baseline certainly shouldn't exceed peak height
////////////////////////////////////////////////////////////////////
// run solver
////////////////////////////////////////////////////////////////////
var solution = NelderMeadSolver.Solve(x => computeGaussianFitQuality(x[0], x[1], x[2], x[3]), coeffs, min, max);
////////////////////////////////////////////////////////////////////
// post-process results
////////////////////////////////////////////////////////////////////
optimalParams = new Params(initialParams);
optimalParams.intensity = solution.GetValue(1); // 1-indexed
optimalParams.wavelength = solution.GetValue(2);
optimalParams.width = solution.GetValue(3);
optimalParams.baseline = solution.GetValue(4);
optimalParams.computeGaussian();
// assuming width has been properly optimized now
double fwhm = 2.0 * Math.Sqrt((2 * Math.Log(2))) * optimalParams.width;
// generate report
logger.log("");
logger.log("NelderMeadSolver:");
logger.log(" Initial: intensity {0:f2}, wavelength {1:f2}, width {2:f2}, baseline {3:f2}", initialParams.intensity, initialParams.wavelength, initialParams.width, initialParams.baseline);
logger.log(" Optimal: intensity {0:f2}, wavelength {1:f2}, width {2:f2}, baseline {3:f2}", optimalParams.intensity, optimalParams.wavelength, optimalParams.width, optimalParams.baseline);
for (int i = 0; i < initialParams.xvalues.Count; i++)
{
logger.log(" {0}, {1:f2}, {2:f2}, {3:f2}{4}",
i,
initialParams.xvalues[i],
initialParams.yvalues[i],
optimalParams.yvalues[i],
i == ((initialParams.xvalues.Count - 1) / 2) ? ", peak" : "");
}
return(fwhm);
}
