public void FletcherReevesRosenbrock()
{
// starting point for search is somewhere
var initialTheta = Vector<double>.Build.DenseOfArray(new[] { -1D, 1D });
// define the hypothesis with default parameter
var rosenbrockParameter = Vector<double>.Build.DenseOfArray(new[] { 1D, 100D });
var hypothesis = new RosenbrockHypothesis();
// cost function is sum of squared errors
var costFunction = new FunctionValueOptimization<double>(hypothesis, rosenbrockParameter);
// define the optimization problem
var problem = new OptimizationProblem<double, IDifferentiableCostFunction<double>>(costFunction, initialTheta);
// define the line search algorithm
var lineSearch = new SecantMethod()
{
ErrorTolerance = 1E-6D
};
// optimize!
var gd = new FletcherReevesCG(lineSearch)
{
MaxIterations = 10000,
ErrorTolerance = 1E-8D
};
var result = gd.Minimize(problem);
// assert!
var coefficients = result.Coefficients;
coefficients[0].Should().BeApproximately(rosenbrockParameter[0], 1E-5D, "because the Rosenbrock function has a minimum at x={0}, y={1}", rosenbrockParameter[0], Math.Sqrt(rosenbrockParameter[0]));
coefficients[1].Should().BeApproximately(Math.Sqrt(rosenbrockParameter[0]), 1E-5D, "because the Rosenbrock function has a minimum at x={0}, y={1}", rosenbrockParameter[0], Math.Sqrt(rosenbrockParameter[0]));
}
public void LinearRegressionWithResidualSumOfSquares()
{
// obtain the test data
var trainingSet = new List<DataPoint<double>>
{
new DataPoint<double>(-1, -1.5),
new DataPoint<double>(0, 0.5),
new DataPoint<double>(1, 2.5),
new DataPoint<double>(2, 4.5),
new DataPoint<double>(3, 6.5)
};
// assume a hypothesis
var hypothesis = new LinearHypothesis(1);
var initialCoefficients = Vector<double>.Build.Random(2);
// cost function is sum of squared errors
var costFunction = new ResidualSumOfSquaresCostFunction(hypothesis, trainingSet);
// define the optimization problem
var problem = new OptimizationProblem<double, IDifferentiableCostFunction<double>>(costFunction, initialCoefficients);
// optimize!
var gd = new ResilientErrorGD
{
ErrorTolerance = 0.0D
};
var result = gd.Minimize(problem);
// assert!
var coefficients = result.Coefficients;
coefficients[0].Should().BeApproximately(0.5, 1E-6D, "because that's the underlying system's intercept");
coefficients[1].Should().BeApproximately(2, 1E-6D, "because that's the underlying system's slope");
}
public SimpleBayesianOptimizerProxy(ModelsDatabase modelsDatabase, OptimizationProblem optimizationProblem, Guid?optimizerId)
{
this.modelsDatabase = modelsDatabase;
this.optimizationProblem = optimizationProblem;
OptimizerId = optimizerId;
optimizerExecutionContext = new SimpleBayesianOptimizerExecutionContext()
{
OptimizerId = optimizerId,
};
optimizerExecutionContext.ModelVersions.Add(0);
}
public CutPattern[] FindSolution(IEnumerable <int> pieceLengths, IEnumerable <int> pieceWidths, IEnumerable <int> pieceDemands, int stockLength, int stockWidth, int stockCost)
{
int[] pLengths = pieceLengths.ToArray <int>();
int[] pWidths = pieceWidths.ToArray <int>();
int[] pDemands = pieceDemands.ToArray <int>();
OptimizationProblem problem = new OptimizationProblem(stockLength, stockWidth, stockCost, pLengths, pWidths, pDemands);
Simplex simp = new Simplex(problem);
CutPattern[] solution = simp.Solve();
return(solution);
}
public void Solve_NaiveOpimitizationSolver()
{
var problem = MapColoring.CreateProblem(5);
var softConstraints = new List <ISoftConstraint <string, int> > {
new NumUniqueConstraint <string, int>(3, problem.Variables)
};
var optimizationProblem = new OptimizationProblem <string, int>(problem.Variables, problem.Constraints, softConstraints, problem.InitialAssignment);
var solver = new NaiveConstraintOptimization <string, int>();
var solution = solver.Optimize(optimizationProblem);
var assigned = new Dictionary <string, int>();
foreach (Variable <string, int> v in problem.Variables)
{
assigned[v.UserObject] = solution.GetValue(v);
}
var adjacencies = new Dictionary <string, List <string> > {
{ "Western Australia", new List <string> {
"Northern Territory", "South Australia"
} },
{ "Northern Territory", new List <string> {
"Western Australia", "South Australia", "Queensland"
} },
{ "New South Wales", new List <string> {
"Queensland", "South Australia", "Victoria"
} },
{ "Queensland", new List <string> {
"Northern Territory", "South Australia", "New South Wales"
} },
{ "South Australia", new List <string> {
"Western Australia", "Northern Territory", "New South Wales", "Queensland", "Victoria"
} },
{ "Victoria", new List <string> {
"New South Wales", "South Australia"
} },
{ "Tasmania", new List <string> {
} }
};
foreach (string t in adjacencies.Keys)
{
var neighbors = adjacencies[t];
foreach (string n in neighbors)
{
Assert.AreNotEqual(assigned[t], assigned[n]);
}
}
Assert.AreEqual(assigned.Values.Distinct().ToList().Count, 3);
}
protected AbstractBinaryCoding(OptimizationProblem problem, int bitsPerContinuousVariable, int bitsPerIntegerVariable)
{
this.continuousVariablesCount = problem.Dimension;
this.continuousLowerBounds = problem.LowerBound;
this.continuousUpperBounds = problem.UpperBound;
this.bitsPerContinuousVariable = bitsPerContinuousVariable;
this.integerVariablesCount = 0;
//this.integerUpperBounds = null;
this.bitsPerIntegerVariable = 0;
this.quantization = new Quantization(bitsPerContinuousVariable);
}
public RealUniformRandomInitializer(OptimizationProblem problem, IGenerator randomNumberGenerator)
{
//problem.CheckInput();
this.continuousVariablesCount = problem.Dimension;
this.lowerBounds = problem.LowerBound;
this.upperBounds = problem.UpperBound;
if (randomNumberGenerator == null)
{
throw new ArgumentException("The random number generator must not be null");
}
this.rng = randomNumberGenerator;
}
public RealUniformHaltonInitializer(OptimizationProblem problem,
HaltonPointGenerator pointGenerator)
{
this.continuousVariablesCount = problem.Dimension;
this.lowerBounds = problem.LowerBound;
this.upperBounds = problem.UpperBound;
if (pointGenerator == null)
{
throw new ArgumentException("The Halton point generator must not be null");
}
this.pointGenerator = pointGenerator;
}
public static void FindSolution(IEnumerable <int> pieceLengths, IEnumerable <int> pieceWidths, IEnumerable <int> pieceDemands, int stockLength, int stockWidth, int stockCost, Worker.Worker worker, out CutPattern[] solution)
{
int[] pLengths = pieceLengths.ToArray <int>();
int[] pWidths = pieceWidths.ToArray <int>();
int[] pDemands = pieceDemands.ToArray <int>();
OptimizationProblem problem = new OptimizationProblem(stockLength, stockWidth, stockCost, pLengths, pWidths, pDemands);
Simplex simp = new Simplex(problem);
solution = simp.Solve(worker);
worker.SetMax();
worker.CallFinish();
}
/// <inheritdoc/>
public IOptimizationProblem GetOptimizationProblem()
{
OptimizerService.OptimizerInfo optimizerInfo = client.GetOptimizerInfo(optimizerHandle);
OptimizationProblem optimizationProblem = OptimizerServiceDecoder.DecodeOptimizationProblem(optimizerInfo.OptimizationProblem);
// Add optimization objectives.
//
optimizationProblem.Objectives.AddRange(
optimizerInfo.OptimizationProblem.Objectives.Select(r =>
new OptimizationObjective(r.Name, r.Minimize)));
return(optimizationProblem);
}
private BayesianOptimizerProxy CreateRemoteOptimizer(OptimizationProblem optimizationProblem)
{
GrpcChannel channel = GrpcChannel.ForAddress(optimizerAddressUri);
var client = new MlosOptimizerService.OptimizerServiceClient(channel);
OptimizerHandle optimizerHandle = client.CreateOptimizer(
new CreateOptimizerRequest
{
OptimizationProblem = optimizationProblem.ToOptimizerServiceOptimizationProblem(),
OptimizerConfig = string.Empty,
});
return(new BayesianOptimizerProxy(client, optimizerHandle));
}
private double[] SolveProgram(OptimizationProblem optimizationProgram)
{
// construct initial value for optimization to be the current value of the parameters
var variables = optimizationProgram.Variables;
var initial = GetCurrentValues(variables);
// run the optimizer
var minimizer = optimizer.Minimize(
optimizationProgram.Objective,
optimizationProgram.Constraints,
optimizationProgram.Variables,
initial).Last();
return(minimizer);
}
public void PolakRibiereRosenbrockParameterFitWithResidualSumOfSquares()
{
// parameter is default Rosenbrock
var realTheta = Vector <double> .Build.DenseOfArray(new[] { 1D, 105D });
var initialTheta = Vector <double> .Build.DenseOfArray(new[] { 2D, 200D });
// define the hypothesis
var hypothesis = new RosenbrockHypothesis();
// define a probability distribution
var distribution = new ContinuousUniform(-10D, 10D);
// obtain the test data
const int dataPoints = 10;
var trainingSet = new List <DataPoint <double> >(dataPoints);
for (int i = 0; i < dataPoints; ++i)
{
var inputs = Vector <double> .Build.Random(2, distribution);
var output = hypothesis.Evaluate(realTheta, inputs);
trainingSet.Add(new DataPoint <double>(inputs, output));
}
;
// cost function is sum of squared errors
var costFunction = new ResidualSumOfSquaresCostFunction(hypothesis, trainingSet);
// define the optimization problem
var problem = new OptimizationProblem <double, IDifferentiableCostFunction <double> >(costFunction, initialTheta);
// define the line search algorithm
var lineSearch = new SecantMethod();
// optimize!
var gd = new PolakRibiereCG(lineSearch)
{
ErrorTolerance = 1E-8D
};
var result = gd.Minimize(problem);
// assert!
var coefficients = result.Coefficients;
coefficients[0].Should().BeApproximately(realTheta[0], 1D, "because that's the functions [a] parameter");
coefficients[1].Should().BeApproximately(realTheta[1], 1D, "because that's the functions [b] parameter");
}
public NelderMeadSimplex(OptimizationProblem optimizationProblem)
{
NelderMeadSimplex.OptProblem = optimizationProblem;
constants = new SimplexConstant[OptProblem.fitnessFunctions.paramValueDictioSize];
int count = 0;
foreach (string subModel in OptProblem.fitnessFunctions.ParamValueDictio.Keys.ToList())
{
foreach (string parameterName in OptProblem.fitnessFunctions.ParamValueDictio[subModel].Keys.ToList())
{
OptiParameter completeParam = OptProblem.Opt_Parameters.Find(ii => ii.Name == parameterName);
constants[count] = new SimplexConstant((completeParam.Max + completeParam.Min) / 2, (completeParam.Max - completeParam.Min) / 2 / 10);
count++;
}
}
}
protected DifferentialEvolutionAlgorithm(OptimizationProblem optimizationProblem, int populationSize,
double mutationFactor, double crossoverProbability, IConvergenceCriterion convergenceCriterion,
Random randomNumberGenerator)
{
this.dimension = optimizationProblem.Dimension;
this.lowerBound = optimizationProblem.LowerBound;
this.upperBound = optimizationProblem.UpperBound;
this.designFactory = optimizationProblem.DesignFactory;
this.populationSize = populationSize;
this.mutationFactor = mutationFactor;
this.crossoverProbability = crossoverProbability;
this.convergenceCriterion = convergenceCriterion;
this.randomNumberGenerator = randomNumberGenerator;
}
public void TestOptimizationProblemNoContext()
{
var in1 = new ContinuousDimension("in_1", 0, 10);
var in2 = new DiscreteDimension("in_2", 1, 20);
var inputHypergrid = new Hypergrid("input", in1, in2);
var out1 = new ContinuousDimension("out_1", -5, 7);
var objectiveHypergrid = new Hypergrid("output", out1);
var objectives = new OptimizationObjective[]
{
new OptimizationObjective("out_1", true),
new OptimizationObjective("nonExistent", false),
};
var optimizationProblem = new OptimizationProblem(inputHypergrid, objectiveHypergrid, objectives);
var serialized = OptimizerServiceEncoder.EncodeOptimizationProblem(optimizationProblem);
var deserialized = OptimizerServiceDecoder.DecodeOptimizationProblem(serialized);
Assert.Null(deserialized.ContextSpace);
}
public BoundaryMutation(OptimizationProblem problem, double mutationProbability, IGenerator randomNumberGenerator)
{
//problem.CheckInput();
this.lowerBounds = problem.LowerBound;
this.upperBounds = problem.UpperBound;
if (mutationProbability < 0 || mutationProbability > 1)
{
throw new ArgumentException("The mutation probability of each gene must belong to the interval [0,1], but was "
+ mutationProbability);
}
this.mutationProbability = mutationProbability;
if (randomNumberGenerator == null)
{
throw new ArgumentException("The random number generator must not be null");
}
this.rng = randomNumberGenerator;
}
private static void Main(string[] args)
{
OptimizationProblem p = new OptimizationProblem();
ReliveAlgorithm solver = new ReliveAlgorithm();
solver.Solve(p);
int[] k = new int[p.n];
for (int i = 0; i < solver.Solution.NoGenes; i++)
{
k[i] = (int)solver.Solution.RealGenes[i];
}
StreamWriter sw = new StreamWriter("result.txt");
Console.WriteLine("Maximizing reliability\r\n");
double cost = 0;
for (int i = 0; i < solver.Solution.NoGenes; i++)
{
cost += p.c[i] * k[i];
}
Console.Write("Solution:\r\n");
for (int i = 0; i < solver.Solution.NoGenes; i++)
{
Console.Write($"{k[i]}, ");
sw.Write($"{k[i]}, ");
}
Console.WriteLine($"\r\nCost: {cost:F0}\r\nReliability: {solver.Solution.Fitness:F4}\r\n");
sw.WriteLine($"\r\nCost: {cost:F0}\r\nReliability: {solver.Solution.Fitness:F4}\r\n");
double eff = p.ComputeEfficiency(k);
Console.WriteLine($"Efficiency: {eff:F2}\r\n");
sw.WriteLine($"Efficiency: {eff:F2}\r\n");
sw.Close();
}
public void UnivariateExponentialRegressionWithResidualSumOfSquares()
{
var theta = Vector <double> .Build.DenseOfArray(new[] { 0D, 13500D, -1.7D });
var initialTheta = Vector <double> .Build.DenseOfArray(new[] { 0D, 10000D, -1D });
// define the hypothesis
var hypothesis = new UnivariateExponentialHypothesis();
// define a probability distribution
var distribution = new ContinuousUniform(0D, 1000D);
// obtain the test data
const int dataPoints = 100;
var trainingSet = new List <DataPoint <double> >(dataPoints);
for (int i = 0; i < dataPoints; ++i)
{
var inputs = Vector <double> .Build.Random(1, distribution);
var output = hypothesis.Evaluate(theta, inputs);
trainingSet.Add(new DataPoint <double>(inputs, output));
}
;
// cost function is sum of squared errors
var costFunction = new ResidualSumOfSquaresCostFunction(hypothesis, trainingSet);
// define the optimization problem
var problem = new OptimizationProblem <double, IDifferentiableCostFunction <double> >(costFunction, initialTheta);
// optimize!
var gd = new HagerZhangCG();
var result = gd.Minimize(problem);
// assert!
var coefficients = result.Coefficients;
coefficients[1].Should().BeApproximately(theta[1], 1000D, "because that's the underlying system's [a] parameter");
coefficients[2].Should().BeApproximately(theta[2], 1E-2D, "because that's the underlying system's [b] parameter");
coefficients[0].Should().BeApproximately(theta[0], 1E-5D, "because that's the underlying system's offset");
}
public void DualLinearRegressionWithResidualSumOfSquares()
{
// obtain the test data
var trainingSet = new List <DataPoint <double> >
{
new DataPoint <double>(-1, new [] { -1.5, -1.0 }),
new DataPoint <double>(0, new [] { 0.5, 1.0 }),
new DataPoint <double>(1, new [] { 2.5, 3.0 }),
new DataPoint <double>(2, new [] { 4.5, 5.0 }),
new DataPoint <double>(3, new [] { 6.5, 6.0 })
};
// assume a hypothesis
var hypothesis = new DualLinearHypothesis(1);
var initialCoefficients = Vector <double> .Build.Random(2);
// cost function is sum of squared errors
var costFunction = new ResidualSumOfSquaresCostFunction(hypothesis, trainingSet);
// define the optimization problem
var problem = new OptimizationProblem <double, IDifferentiableCostFunction <double> >(costFunction, initialCoefficients);
// define the line search algorithm
var lineSearch = new SecantMethod()
{
ErrorTolerance = 1E-7
};
// optimize!
var gd = new FletcherReevesCG(lineSearch)
{
ErrorTolerance = 1E-7
};
var result = gd.Minimize(problem);
// assert!
var coefficients = result.Coefficients;
coefficients[0].Should().BeApproximately(0.5, 1E-6D, "because that's the underlying system's intercept");
coefficients[1].Should().BeApproximately(2, 1E-6D, "because that's the underlying system's slope");
}
public void Report(OptimizationProblem problem)
{
WriteLine("");
WriteLine("Report for problem " + problem.Name);
WriteLine("================================================");
WriteLine("");
WriteLine("Objective Function");
WriteLine(String.Format("F = {0,12:G6} [{1}]", problem.ObjectiveFunction.Eval(new Evaluator()), problem.ObjectiveFunction.ToString()));
WriteLine("");
WriteLine("Constraints");
foreach (var constraint in problem.Constraints)
{
WriteLine(String.Format("C = {0,12:G6} [{1}]", constraint.Residual(new Evaluator()), constraint.ToString()));
}
WriteLine("");
WriteLine("Decisions");
foreach (var variable in problem.DecisionVariables)
{
WriteLine(String.Format("{0,12:G6} <= {1,10} = {2,12:G6} <= {3,12:G6} [{4}]", variable.LowerBound, variable.FullName, variable.ValueInSI, variable.UpperBound, variable.InternalUnit));
}
}
public ConstantGaussianMutation(OptimizationProblem problem, double standardDeviation, IGenerator randomNumberGenerator)
{
//problem.CheckInput();
this.continuousVariablesCount = problem.Dimension;
if (standardDeviation <= 0)
{
throw new ArgumentException("Standard deviation must be > 0, but was " + standardDeviation);
}
this.standardDeviations = new double[continuousVariablesCount];
for (int i = 0; i < problem.Dimension; ++i)
{
this.standardDeviations[i] = standardDeviation;
}
if (randomNumberGenerator == null)
{
throw new ArgumentException("The random number generator must not be null");
}
this.normalDistribution = new NormalDistribution(randomNumberGenerator, 0, 1);
}
public void DualLinearRegressionWithResidualSumOfSquares()
{
// obtain the test data
var trainingSet = new List<DataPoint<double>>
{
new DataPoint<double>(-1, new [] {-1.5 , -1.0 }),
new DataPoint<double>(0, new [] {0.5, 1.0}),
new DataPoint<double>(1, new [] {2.5, 3.0}),
new DataPoint<double>(2, new [] {4.5, 5.0}),
new DataPoint<double>(3, new [] {6.5, 6.0})
};
// assume a hypothesis
var hypothesis = new DualLinearHypothesis(1);
var initialCoefficients = Vector<double>.Build.Random(2);
// cost function is sum of squared errors
var costFunction = new ResidualSumOfSquaresCostFunction(hypothesis, trainingSet);
// define the optimization problem
var problem = new OptimizationProblem<double, IDifferentiableCostFunction<double>>(costFunction, initialCoefficients);
// define the line search algorithm
var lineSearch = new SecantMethod()
{
ErrorTolerance = 1E-7
};
// optimize!
var gd = new FletcherReevesCG(lineSearch)
{
ErrorTolerance = 1E-7
};
var result = gd.Minimize(problem);
// assert!
var coefficients = result.Coefficients;
coefficients[0].Should().BeApproximately(0.5, 1E-6D, "because that's the underlying system's intercept");
coefficients[1].Should().BeApproximately(2, 1E-6D, "because that's the underlying system's slope");
}
public void PolakRibiereRosenbrock()
{
// starting point for search is somewhere
var initialTheta = Vector <double> .Build.DenseOfArray(new[] { -1D, 1D });
// define the hypothesis with default parameter
var rosenbrockParameter = Vector <double> .Build.DenseOfArray(new[] { 1D, 100D });
var hypothesis = new RosenbrockHypothesis();
// cost function is sum of squared errors
var costFunction = new FunctionValueOptimization <double>(hypothesis, rosenbrockParameter);
// define the optimization problem
var problem = new OptimizationProblem <double, IDifferentiableCostFunction <double> >(costFunction, initialTheta);
// define the line search algorithm
var lineSearch = new SecantMethod
{
LineSearchStepSize = 1E-5D
};
// optimize!
var gd = new PolakRibiereCG(lineSearch)
{
ErrorTolerance = 1E-8D,
MaxIterations = 15000
};
var result = gd.Minimize(problem);
// assert!
var coefficients = result.Coefficients;
coefficients[0].Should().BeApproximately(rosenbrockParameter[0], 1E-5D, "because the Rosenbrock function has a minimum at x={0}, y={1}", rosenbrockParameter[0], Math.Sqrt(rosenbrockParameter[0]));
coefficients[1].Should().BeApproximately(Math.Sqrt(rosenbrockParameter[0]), 1E-5D, "because the Rosenbrock function has a minimum at x={0}, y={1}", rosenbrockParameter[0], Math.Sqrt(rosenbrockParameter[0]));
}
public StandardBinaryCoding(OptimizationProblem problem, int bitsPerContinuousVariable, int bitsPerIntegerVariable) :
base(problem, bitsPerContinuousVariable, bitsPerIntegerVariable)
{
}
protected Builder(OptimizationProblem problem)
{
this.problem = problem;
}
public CMAESMain(OptimizationProblem optimizationProblem)
{
CMAESMain.OptProblem = optimizationProblem;
}
public bool Solve(OptimizationProblem problem)
{
ProblemData = problem;
return(Solve());
}
public RealCodedGeneticAlgorithmBuilder(OptimizationProblem problem) : base(problem)
{
this.problem = problem;
}
public Builder(OptimizationProblem optimizationProblem)
{
ProblemChecker.Check(optimizationProblem);
this.optimizationProblem = optimizationProblem;
}
public Builder(OptimizationProblem optimizationProblem)
{
this.optimizationProblem = optimizationProblem;
}
public void UnivariateExponentialRegressionWithResidualSumOfSquares()
{
var theta = Vector<double>.Build.DenseOfArray(new[] { 0D, 13500D, -1.7D });
var initialTheta = Vector<double>.Build.DenseOfArray(new[] { 0D, 10000D, -1D });
// define the hypothesis
var hypothesis = new UnivariateExponentialHypothesis();
// define a probability distribution
var distribution = new ContinuousUniform(0D, 1000D);
// obtain the test data
const int dataPoints = 100;
var trainingSet = new List<DataPoint<double>>(dataPoints);
for (int i = 0; i < dataPoints; ++i)
{
var inputs = Vector<double>.Build.Random(1, distribution);
var output = hypothesis.Evaluate(theta, inputs);
trainingSet.Add(new DataPoint<double>(inputs, output));
};
// cost function is sum of squared errors
var costFunction = new ResidualSumOfSquaresCostFunction(hypothesis, trainingSet);
// define the optimization problem
var problem = new OptimizationProblem<double, IDifferentiableCostFunction<double>>(costFunction, initialTheta);
// optimize!
var gd = new ResilientErrorGD();
var result = gd.Minimize(problem);
// assert!
var coefficients = result.Coefficients;
coefficients[1].Should().BeApproximately(theta[1], 1000D, "because that's the underlying system's [a] parameter");
coefficients[2].Should().BeApproximately(theta[2], 1E-2D, "because that's the underlying system's [b] parameter");
coefficients[0].Should().BeApproximately(theta[0], 1E-5D, "because that's the underlying system's offset");
}
public void RosenbrockParameterFitWithResidualSumOfSquares()
{
// parameter is default Rosenbrock
var realTheta = Vector<double>.Build.DenseOfArray(new []{1D, 105D});
var initialTheta = Vector<double>.Build.DenseOfArray(new []{2D, 200D});
// define the hypothesis
var hypothesis = new RosenbrockHypothesis();
// define a probability distribution
var distribution = new ContinuousUniform(-10D, 10D);
// obtain the test data
const int dataPoints = 10;
var trainingSet = new List<DataPoint<double>>(dataPoints);
for (int i = 0; i < dataPoints; ++i)
{
var inputs = Vector<double>.Build.Random(2, distribution);
var output = hypothesis.Evaluate(realTheta, inputs);
trainingSet.Add(new DataPoint<double>(inputs, output));
};
// cost function is sum of squared errors
var costFunction = new ResidualSumOfSquaresCostFunction(hypothesis, trainingSet);
// define the optimization problem
var problem = new OptimizationProblem<double, IDifferentiableCostFunction<double>>(costFunction, initialTheta);
// optimize!
var gd = new ResilientErrorGD
{
ErrorTolerance = 0.0D // TODO: actually use it
};
var result = gd.Minimize(problem);
// assert!
var coefficients = result.Coefficients;
coefficients[0].Should().BeApproximately(realTheta[0], 1D, "because that's the functions [a] parameter");
coefficients[1].Should().BeApproximately(realTheta[1], 1D, "because that's the functions [b] parameter");
}
public BoundaryMutation(OptimizationProblem problem, double mutationProbability) :
this(problem, mutationProbability, RandomNumberGenerationUtilities.troschuetzRandom)
{
}
/// <summary>
/// This is the entry point for setting up the message handlers for the
/// messages code generated from the (partial) structs defined for this
/// smart component in the CodeGen/SmartCache.cs.
/// </summary>
/// <remarks>
/// See class comments for further details.
/// </remarks>
static AssemblyInitializer()
{
// Setup message callbacks.
//
// Note: these message properties are code generated from the
// (partial) structs in CodeGen/SmartCache.cs
//
// See out/Mlos.CodeGen.out/SmartCache/*.cs for the C# code
// generation output from those partial definitions.
//
SmartCacheProxy.CacheRequestEventMessage.Callback = CacheRequestEventMessageHandler;
SmartCacheProxy.RequestNewConfigurationMessage.Callback = RequestNewConfigurationMessageHandler;
// Create smart cache parameter search space.
//
// These hypergrids define the combination of valid ranges
// of values for the different tunables.
// Note that some of these are interdependent.
//
// TODO: Eventually this will also be code generated from additional
// "domain range" attributes on the "ScalarSettings" defined for the
// component (see also CodeGen/SmartCache.cs)
//
Hypergrid cacheSearchSpace = new Hypergrid(
name: "smart_cache_config",
dimension: new CategoricalDimension("cache_implementation", CacheEvictionPolicy.LeastRecentlyUsed, CacheEvictionPolicy.MostRecentlyUsed))
.Join(
subgrid: new Hypergrid(
name: "lru_cache_config",
dimension: new DiscreteDimension("cache_size", min: 1, max: 1 << 12)),
onExternalDimension: new CategoricalDimension("cache_implementation", CacheEvictionPolicy.LeastRecentlyUsed))
.Join(
subgrid: new Hypergrid(
name: "mru_cache_config",
dimension: new DiscreteDimension("cache_size", min: 1, max: 1 << 12)),
onExternalDimension: new CategoricalDimension("cache_implementation", CacheEvictionPolicy.MostRecentlyUsed));
// Create optimization problem.
//
// Here we declare to the optimizer what our desired output from the
// component to optimize is.
//
// In this case we declare "hit rate", which will be calculated as a
// percentage, is the thing we want the optimizer to improve.
//
var optimizationProblem = new OptimizationProblem
{
ParameterSpace = cacheSearchSpace,
ContextSpace = null,
ObjectiveSpace = new Hypergrid(
name: "objectives",
dimensions: new ContinuousDimension(name: "HitRate", min: 0.0, max: 1.0)),
};
// Define optimization objective.
//
optimizationProblem.Objectives.Add(
new OptimizationObjective
{
// Tell the optimizer that we want to maximize hit rate.
//
Name = "HitRate",
Minimize = false,
});
// Get a local reference to the optimizer to reuse when processing messages later on.
//
// Note: we read this from a global variable that should have been
// setup for the Mlos.Agent (e.g. in the Mlos.Agent.Server).
//
IOptimizerFactory optimizerFactory = MlosContext.OptimizerFactory;
OptimizerProxy = optimizerFactory?.CreateRemoteOptimizer(optimizationProblem: optimizationProblem);
}
