public void GlobalizedBoundedNelderMeadOptimizer_Optimize(int?maxDegreeOfParallelism)
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(0.0, 100.0, Transform.Linear)
};
var sut = maxDegreeOfParallelism.HasValue ?
new GlobalizedBoundedNelderMeadOptimizer(parameters, 5, 1e-5, 10,
maxDegreeOfParallelism: maxDegreeOfParallelism.Value) :
new GlobalizedBoundedNelderMeadOptimizer(parameters, 5, 1e-5, 10);
var results = sut.Optimize(MinimizeWeightFromHeight);
var actual = new OptimizerResult[] { results.First(), results.Last() };
var expected = new OptimizerResult[]
{
new OptimizerResult(new double[] { 37.71314535727786 }, 109.34381396310141),
new OptimizerResult(new double[] { 37.7131485180996 }, 109.34381396350526)
};
Assert.AreEqual(expected.First().Error, actual.First().Error, Delta);
Assert.AreEqual(expected.First().ParameterSet.First(),
actual.First().ParameterSet.First(), Delta);
Assert.AreEqual(expected.Last().Error, actual.Last().Error, Delta);
Assert.AreEqual(expected.Last().ParameterSet.First(),
actual.Last().ParameterSet.First(), Delta);
}
public void BayesianOptimizer_Optimize()
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(0.0, 100.0, Transform.Linear)
};
var sut = new BayesianOptimizer(parameters,
iterations: 120,
randomStartingPointCount: 5,
functionEvaluationsPerIterationCount: 1,
randomSearchPointCount: 1000,
seed: 42,
runParallel: false); // Note, since the returned results are not ordered on error,
// running with parallel computations will not return reproducible order of results,
// so runParallel must be false for this test.
var results = sut.Optimize(MinimizeWeightFromHeight);
var actual = new OptimizerResult[] { results.First(), results.Last() };
var expected = new OptimizerResult[]
{
new OptimizerResult(new double[] { 43.216748276360683 }, 1352.8306605984087),
new OptimizerResult(new double[] { 38.201425707992833 }, 119.1316225267316)
};
Assert.AreEqual(expected.First().Error, actual.First().Error, Delta);
Assert.AreEqual(expected.First().ParameterSet.First(), actual.First().ParameterSet.First(), Delta);
Assert.AreEqual(expected.Last().Error, actual.Last().Error, Delta);
Assert.AreEqual(expected.Last().ParameterSet.First(), actual.Last().ParameterSet.First(), Delta);
}
public void SmacOptimizer_OptimizeBest_MultipleParameters()
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
};
var sut = new SmacOptimizer(parameters,
iterations: 80,
randomStartingPointCount: 20,
functionEvaluationsPerIterationCount: 1,
localSearchPointCount: 10,
randomSearchPointCount: 1000,
epsilon: 0.00001,
seed: 42);
var actual = sut.OptimizeBest(Minimize);
Assert.AreEqual(-0.964878416222769, actual.Error, Delta);
Assert.AreEqual(actual.ParameterSet.Length, 3);
Assert.AreEqual(-7.8487638560350819, actual.ParameterSet[0], Delta);
Assert.AreEqual(6.2840940040927826, actual.ParameterSet[1], Delta);
Assert.AreEqual(0.036385473812179825, actual.ParameterSet[2], Delta);
}
OptimizerResult RunOpenLoopOptimizationTest(List <OptimizerResult> results)
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
};
var iterations = 80;
var randomStartingPointsCount = 20;
var functionEvaluationsPerIterationCount = 1;
var sut = new BayesianOptimizer(parameters,
iterations: iterations,
randomStartingPointCount: randomStartingPointsCount,
functionEvaluationsPerIterationCount: functionEvaluationsPerIterationCount,
randomSearchPointCount: 1000,
seed: 42);
// Using BayesianOptimizer in an open loop.
var initialParameterSets = sut.ProposeParameterSets(randomStartingPointsCount, results);
var initializationResults = sut.RunParameterSets(Minimize, initialParameterSets);
results.AddRange(initializationResults);
for (int i = 0; i < iterations; i++)
{
var parameterSets = sut.ProposeParameterSets(functionEvaluationsPerIterationCount, results);
var iterationResults = sut.RunParameterSets(Minimize, parameterSets);
results.AddRange(iterationResults);
}
return(results.Where(v => !double.IsNaN(v.Error)).OrderBy(r => r.Error).First());
}
public void SmacOptimizer_Optimize()
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(0.0, 100.0, Transform.Linear)
};
var sut = new SmacOptimizer(parameters,
iterations: 80,
randomStartingPointCount: 20,
functionEvaluationsPerIterationCount: 1,
localSearchPointCount: 10,
randomSearchPointCount: 1000,
epsilon: 0.00001,
seed: 42);
var actual = sut.Optimize(MinimizeWeightFromHeight);
var expected = new OptimizerResult[]
{
new OptimizerResult(new double[] { 90.513222660177 }, 114559.431919558),
new OptimizerResult(new double[] { 41.8333740634068 }, 806.274612132759),
};
Assert.AreEqual(expected.First().Error, actual.First().Error, Delta);
Assert.AreEqual(expected.First().ParameterSet.First(), actual.First().ParameterSet.First(), Delta);
Assert.AreEqual(expected.Last().Error, actual.Last().Error, Delta);
Assert.AreEqual(expected.Last().ParameterSet.First(), actual.Last().ParameterSet.First(), Delta);
}
public void GlobalizedBoundedNelderMeadOptimizer_Optimize(int?maxDegreeOfParallelism)
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(0.0, 100.0, Transform.Linear)
};
var sut = CreateSut(maxDegreeOfParallelism, parameters);
var results = sut.Optimize(MinimizeWeightFromHeight);
var actual = new OptimizerResult[] { results.First(), results.Last() };
var expected = new OptimizerResult[]
{
new OptimizerResult(new double[] { 37.71314634450421 }, 109.3438139631394),
new OptimizerResult(new double[] { 37.713142445047254 }, 109.34381396345546)
};
Assert.AreEqual(expected.First().Error, actual.First().Error, Delta);
Assert.AreEqual(expected.First().ParameterSet.First(),
actual.First().ParameterSet.First(), Delta);
Assert.AreEqual(expected.Last().Error, actual.Last().Error, Delta);
Assert.AreEqual(expected.Last().ParameterSet.First(),
actual.Last().ParameterSet.First(), Delta);
}
public void ParticleSwarmOptimizer_Optimize(int?maxDegreeOfParallelism)
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(0.0, 100.0, Transform.Linear)
};
var sut = maxDegreeOfParallelism.HasValue ?
new ParticleSwarmOptimizer(parameters, 100, maxDegreeOfParallelism: maxDegreeOfParallelism.Value) :
new ParticleSwarmOptimizer(parameters, 100);
var results = sut.Optimize(Minimize2);
var actual = new OptimizerResult[] { results.First(), results.Last() };
var expected = new OptimizerResult[]
{
new OptimizerResult(new double[] { 38.1151505704492 }, 115.978346548015),
new OptimizerResult(new double[] { 37.2514904205637 }, 118.093289672808),
};
Assert.AreEqual(expected.First().Error, actual.First().Error, 0.0001);
Assert.AreEqual(expected.First().ParameterSet.First(), actual.First().ParameterSet.First(), 0.0001);
Assert.AreEqual(expected.Last().Error, actual.Last().Error, 0.0001);
Assert.AreEqual(expected.Last().ParameterSet.First(), actual.Last().ParameterSet.First(), 0.0001);
}
public void RandomSearchOptimizer_Optimize(int?maxDegreeOfParallelism)
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(10.0, 37.5, Transform.Linear)
};
var sut = maxDegreeOfParallelism.HasValue ?
new RandomSearchOptimizer(parameters, 2, 42, true, maxDegreeOfParallelism.Value) :
new RandomSearchOptimizer(parameters, 2);
var actual = sut.Optimize(MinimizeWeightFromHeight);
var expected = new OptimizerResult[]
{
new OptimizerResult(new double[] { 13.8749507052707 }, 23438.2157641635),
new OptimizerResult(new double[] { 28.3729278125674 }, 3690.81119818742),
};
Assert.AreEqual(expected.First().Error, actual.First().Error, Delta);
Assert.AreEqual(expected.First().ParameterSet.First(),
actual.First().ParameterSet.First(), Delta);
Assert.AreEqual(expected.Last().Error, actual.Last().Error, Delta);
Assert.AreEqual(expected.Last().ParameterSet.First(),
actual.Last().ParameterSet.First(), Delta);
}
public void ParameterBounds_NextValue()
{
var sut = new MinMaxParameterSpec(min: 20, max: 200,
transform: Transform.Linear);
var sampler = new RandomUniform(seed: 32);
var actual = new double[10];
for (int i = 0; i < actual.Length; i++)
{
actual[i] = sut.SampleValue(sampler: sampler);
}
var expected = new double[]
{
99.8935983236384,
57.2098020451189,
44.4149092419142,
89.9002946307418,
137.643828772774,
114.250629522954,
63.8914499915631,
109.294177409864,
188.567149950455,
33.2731248034505
};
Assert.AreEqual(expected.Length, actual.Length);
for (int i = 0; i < expected.Length; i++)
{
Assert.AreEqual(expected[i], actual[i], 0.000001);
}
}
public void BayesianOptimizer_OptimizeBest_MultipleParameters(bool runParallel)
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
};
var sut = new BayesianOptimizer(parameters,
iterations: 100,
randomStartingPointCount: 5,
functionEvaluationsPerIterationCount: 1,
randomSearchPointCount: 1000,
seed: 42,
runParallel: runParallel);
var actual = sut.OptimizeBest(Minimize);
Assert.AreEqual(-0.76070603822760785, actual.Error, Delta);
Assert.AreEqual(3, actual.ParameterSet.Length);
Assert.AreEqual(1.6078245041928358, actual.ParameterSet[0], Delta);
Assert.AreEqual(-8.9735394990879769, actual.ParameterSet[1], Delta);
Assert.AreEqual(-0.18217921731163855, actual.ParameterSet[2], Delta);
}
public void RandomSearchOptimizer_Optimize(int?maxDegreeOfParallelism)
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(10.0, 37.5, Transform.Linear)
};
var sut = maxDegreeOfParallelism.HasValue ?
new RandomSearchOptimizer(parameters, 100, 42, true, maxDegreeOfParallelism.Value) :
new RandomSearchOptimizer(parameters, 100);
var actual = sut.Optimize(MinimizeWeightFromHeight);
var expected = new OptimizerResult[]
{
new OptimizerResult(new double[] { 28.3729278125674 }, 3690.81119818742),
new OptimizerResult(new double[] { 19.1529422843144 }, 14251.396910816733),
};
Assert.AreEqual(expected.First().Error, actual.First().Error, Delta);
Assert.AreEqual(expected.First().ParameterSet.First(),
actual.First().ParameterSet.First(), Delta);
Assert.AreEqual(expected.Last().Error, actual.Last().Error, Delta);
Assert.AreEqual(expected.Last().ParameterSet.First(),
actual.Last().ParameterSet.First(), Delta);
}
public void ParticleSwarmOptimizer_Optimize(int?maxDegreeOfParallelism)
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(0.0, 100.0, Transform.Linear)
};
var sut = CreateSut(maxDegreeOfParallelism, parameters);
var results = sut.Optimize(MinimizeWeightFromHeight);
var actual = new OptimizerResult[] { results.First(), results.Last() };
var expected = new OptimizerResult[]
{
new OptimizerResult(new double[] { 38.1151505704492 }, 115.978346548015),
new OptimizerResult(new double[] { 37.2514904205637 }, 118.093289672808),
};
Assert.AreEqual(expected.First().Error, actual.First().Error, Delta);
Assert.AreEqual(expected.First().ParameterSet.First(),
actual.First().ParameterSet.First(), Delta);
Assert.AreEqual(expected.Last().Error, actual.Last().Error, Delta);
Assert.AreEqual(expected.Last().ParameterSet.First(),
actual.Last().ParameterSet.First(), Delta);
}
public void SmacOptimizer_OptimizeBest_SingleParameter()
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(0.0, 100.0, Transform.Linear)
};
var sut = CreateSut(parameters);
var actual = sut.OptimizeBest(MinimizeWeightFromHeight);
Assert.AreEqual(109.616853578648, actual.Error, Delta);
Assert.AreEqual(37.6315924979893, actual.ParameterSet.Single(), Delta);
}
public void BayesianOptimizer_OptimizeBest_SingleParameter(int?maxDegreeOfParallelism)
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(0.0, 100.0, Transform.Linear)
};
var sut = CreateSut(maxDegreeOfParallelism, parameters);
var actual = sut.OptimizeBest(MinimizeWeightFromHeight);
Assert.AreEqual(110.050490091126, actual.Error, Delta);
Assert.AreEqual(37.84434624847227, actual.ParameterSet.Single(), Delta);
}
public void BayesianOptimizer_OptimizeNonDeterministicInParallel()
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(0, 1, Transform.Linear, ParameterType.Discrete)
};
var sut = new BayesianOptimizer(parameters, iterations: 240, randomStartingPointCount: 5, functionEvaluationsPerIteration: 5,
seed: Seed, maxDegreeOfParallelism: -1, allowMultipleEvaluations: true);
var results = sut.Optimize(p => MinimizeNonDeterministic(p, Random));
var actual = new OptimizerResult[] { results.First(), results.Last() }.OrderByDescending(o => o.Error);
Assert.AreEqual(1, actual.First().Error);
Assert.AreEqual(1, (int)actual.First().ParameterSet[0]);
}
public void RandomSearchOptimizer_OptimizeBest(int?maxDegreeOfParallelism)
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(0.0, 100.0, Transform.Linear)
};
var sut = maxDegreeOfParallelism.HasValue ?
new RandomSearchOptimizer(parameters, 100, 42, true, maxDegreeOfParallelism.Value) :
new RandomSearchOptimizer(parameters, 100);
var actual = sut.OptimizeBest(MinimizeWeightFromHeight);
Assert.AreEqual(110.67173923600831, actual.Error, Delta);
Assert.AreEqual(37.533294194160632, actual.ParameterSet.Single(), Delta);
}
public void BayesianOptimizer_OptimizeBest()
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
};
var sut = new BayesianOptimizer(parameters, 100, 5, 1);
var actual = sut.OptimizeBest(Minimize);
Assert.AreEqual(actual.Error, -0.74765422244251278, 0.0001);
Assert.AreEqual(actual.ParameterSet.Length, 3);
Assert.AreEqual(-5.0065683270835173, actual.ParameterSet[0], Delta);
Assert.AreEqual(-9.67008227467075, actual.ParameterSet[1], Delta);
Assert.AreEqual(-0.24173704452893574, actual.ParameterSet[2], Delta);
}
public void BayesianOptimizer_OptimizeBestInParallel()
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
};
//high variance without fixed seed
var sut = new BayesianOptimizer(parameters, 100, 5, 2, seed: Seed);
var actual = sut.OptimizeBest(Minimize);
Assert.AreEqual(-0.736123479387088, actual.Error, Delta);
Assert.AreEqual(3, actual.ParameterSet.Length);
Assert.AreEqual(-4.37019084318084, actual.ParameterSet[0], Delta);
Assert.AreEqual(-3.05224638108734, actual.ParameterSet[1], Delta);
Assert.AreEqual(0.274598500819224, actual.ParameterSet[2], Delta);
}
public void BayesianOptimizer_OptimizeBest_SingleParameter(bool runParallel)
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(0.0, 100.0, Transform.Linear)
};
var sut = new BayesianOptimizer(parameters,
iterations: 80,
randomStartingPointCount: 20,
functionEvaluationsPerIterationCount: 1,
randomSearchPointCount: 1000,
seed: 42,
runParallel: runParallel);
var actual = sut.OptimizeBest(MinimizeWeightFromHeight);
Assert.AreEqual(126.50056735005998, actual.Error, Delta);
Assert.AreEqual(38.359608938153649, actual.ParameterSet.Single(), Delta);
}
public void GlobalizedBoundedNelderMeadOptimizer_OptimizeBest(int?maxDegreeOfParallelism)
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
};
var sut = CreateSut(maxDegreeOfParallelism, parameters);
var actual = sut.OptimizeBest(Minimize);
Assert.AreEqual(actual.Error, -0.99999960731425908, Delta);
Assert.AreEqual(actual.ParameterSet.Length, 3);
Assert.AreEqual(actual.ParameterSet[0], -1.5711056814954487, Delta);
Assert.AreEqual(actual.ParameterSet[1], -6.283490634742785, Delta);
Assert.AreEqual(actual.ParameterSet[2], -2.9822323517533149E-07, Delta);
}
public void SmacOptimizer_OptimizeBest_MultipleParameters()
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
};
var sut = CreateSut(parameters);
var actual = sut.OptimizeBest(Minimize);
Assert.AreEqual(-0.964878416222769, actual.Error, Delta);
Assert.AreEqual(actual.ParameterSet.Length, 3);
Assert.AreEqual(-7.8487638560350819, actual.ParameterSet[0], Delta);
Assert.AreEqual(6.2840940040927826, actual.ParameterSet[1], Delta);
Assert.AreEqual(0.036385473812179825, actual.ParameterSet[2], Delta);
}
public void BayesianOptimizer_OptimizeBest_MultipleParameters(int?maxDegreeOfParallelism)
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
};
var sut = CreateSut(maxDegreeOfParallelism, parameters);
var actual = sut.OptimizeBest(Minimize);
Assert.AreEqual(-0.59028531714984367, actual.Error, Delta);
Assert.AreEqual(3, actual.ParameterSet.Length);
Assert.AreEqual(3.9675549296511132, actual.ParameterSet[0], Delta);
Assert.AreEqual(6.8542302757754143, actual.ParameterSet[1], Delta);
Assert.AreEqual(-0.047884811669533178, actual.ParameterSet[2], Delta);
}
public void ParticleSwarmOptimizer_OptimizeBest(int?maxDegreeOfParallelism)
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
};
var sut = CreateSut(maxDegreeOfParallelism, parameters);
var actual = sut.OptimizeBest(Minimize);
Assert.AreEqual(-0.64324321766401094, actual.Error, Delta);
Assert.AreEqual(3, actual.ParameterSet.Length);
Assert.AreEqual(-4.92494268653156, actual.ParameterSet[0], Delta);
Assert.AreEqual(10, actual.ParameterSet[1], Delta);
Assert.AreEqual(-0.27508308116943514, actual.ParameterSet[2], Delta);
}
public void SmacOptimizer_OptimizeBest_SingleParameter()
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(0.0, 100.0, Transform.Linear)
};
var sut = new SmacOptimizer(parameters,
iterations: 80,
randomStartingPointCount: 20,
functionEvaluationsPerIterationCount: 1,
localSearchPointCount: 10,
randomSearchPointCount: 1000,
epsilon: 0.00001,
seed: 42);
var actual = sut.OptimizeBest(MinimizeWeightFromHeight);
Assert.AreEqual(109.616853578648, actual.Error, Delta);
Assert.AreEqual(37.6315924979893, actual.ParameterSet.Single(), Delta);
}
public void ParticleSwarmOptimizer_OptimizeBest(int?maxDegreeOfParallelism)
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
};
var sut = maxDegreeOfParallelism.HasValue ?
new ParticleSwarmOptimizer(parameters, 100, maxDegreeOfParallelism: maxDegreeOfParallelism.Value) :
new ParticleSwarmOptimizer(parameters, 100);
var actual = sut.OptimizeBest(Minimize);
Assert.AreEqual(actual.Error, -0.64324321766401094, 0.0000001);
Assert.AreEqual(actual.ParameterSet.Length, 3);
Assert.AreEqual(actual.ParameterSet[0], -4.92494268653156, 0.0000001);
Assert.AreEqual(actual.ParameterSet[1], 10, 0.0000001);
Assert.AreEqual(actual.ParameterSet[2], -0.27508308116943514, 0.0000001);
}
public void BayesianOptimizer_Optimize()
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(0.0, 100.0, Transform.Linear)
};
var sut = new BayesianOptimizer(parameters, 120, 5, 1);
var results = sut.Optimize(Minimize2);
var actual = new OptimizerResult[] { results.First(), results.Last() };
var expected = new OptimizerResult[]
{
new OptimizerResult(new double[] { 90.513222660177 }, 114559.431919558),
new OptimizerResult(new double[] { 24.204380402436 }, 7601.008090362)
};
Assert.AreEqual(expected.First().Error, actual.First().Error, m_delta);
Assert.AreEqual(expected.First().ParameterSet.First(), actual.First().ParameterSet.First(), m_delta);
Assert.AreEqual(expected.Last().Error, actual.Last().Error, m_delta);
Assert.AreEqual(expected.Last().ParameterSet.First(), actual.Last().ParameterSet.First(), m_delta);
}
public void SmacOptimizer_Optimize()
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(0.0, 100.0, Transform.Linear)
};
var sut = CreateSut(parameters);
var actual = sut.Optimize(MinimizeWeightFromHeight);
var expected = new OptimizerResult[]
{
new OptimizerResult(new double[] { 90.513222660177 }, 114559.431919558),
new OptimizerResult(new double[] { 41.8333740634068 }, 806.274612132759),
};
Assert.AreEqual(expected.First().Error, actual.First().Error, Delta);
Assert.AreEqual(expected.First().ParameterSet.First(), actual.First().ParameterSet.First(), Delta);
Assert.AreEqual(expected.Last().Error, actual.Last().Error, Delta);
Assert.AreEqual(expected.Last().ParameterSet.First(), actual.Last().ParameterSet.First(), Delta);
}
public void GlobalizedBoundedNelderMeadOptimizer_OptimizeBest(int?maxDegreeOfParallelism)
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
new MinMaxParameterSpec(-10.0, 10.0, Transform.Linear),
};
var sut = maxDegreeOfParallelism.HasValue ?
new GlobalizedBoundedNelderMeadOptimizer(parameters, 5, 1e-5, 10,
maxDegreeOfParallelism: maxDegreeOfParallelism.Value) :
new GlobalizedBoundedNelderMeadOptimizer(parameters, 5, 1e-5, 10);
var actual = sut.OptimizeBest(Minimize);
Assert.AreEqual(actual.Error, -0.99999949547279676, Delta);
Assert.AreEqual(actual.ParameterSet.Length, 3);
Assert.AreEqual(actual.ParameterSet[0], -7.8547285710964134, Delta);
Assert.AreEqual(actual.ParameterSet[1], 6.2835515298977995, Delta);
Assert.AreEqual(actual.ParameterSet[2], -1.5851024386788885E-07, Delta);
}
public void BayesianOptimizer_Optimize()
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(0.0, 100.0, Transform.Linear)
};
var sut = new BayesianOptimizer(parameters, 120, 5, 1, maxDegreeOfParallelism: 1);
var results = sut.Optimize(MinimizeWeightFromHeight);
var actual = new OptimizerResult[] { results.First(), results.Last() }.OrderByDescending(o => o.Error);
var expected = new OptimizerResult[]
{
new OptimizerResult(new double[] { 90.513222660177 }, 114559.431919558),
new OptimizerResult(new double[] { 24.2043804024367 }, 7601.00809036235)
};
Assert.AreEqual(expected.First().Error, actual.First().Error, Delta);
Assert.AreEqual(expected.First().ParameterSet.First(),
actual.First().ParameterSet.First(), Delta);
Assert.AreEqual(expected.Last().Error, actual.Last().Error, Delta);
Assert.AreEqual(expected.Last().ParameterSet.First(),
actual.Last().ParameterSet.First(), Delta);
}
public void BayesianOptimizer_Optimize(int?maxDegreeOfParallelism)
{
var parameters = new MinMaxParameterSpec[]
{
new MinMaxParameterSpec(0.0, 100.0, Transform.Linear)
};
var sut = CreateSut(maxDegreeOfParallelism, parameters);
var results = sut.Optimize(MinimizeWeightFromHeight);
var actual = new OptimizerResult[] { results.First(), results.Last() };
var expected = new OptimizerResult[]
{
new OptimizerResult(new double[] { 90.513222660177036 }, 114559.43191955783),
new OptimizerResult(new double[] { 41.752538896050559 }, 779.196560786838)
};
Assert.AreEqual(expected.First().Error, actual.First().Error, Delta);
Assert.AreEqual(expected.First().ParameterSet.First(), actual.First().ParameterSet.First(), Delta);
Assert.AreEqual(expected.Last().Error, actual.Last().Error, Delta);
Assert.AreEqual(expected.Last().ParameterSet.First(), actual.Last().ParameterSet.First(), Delta);
}
