public override double Evaluate(IChromosome chromosome)
{
try
{
var parameters = Config.Genes.Select(s =>
new MinMaxParameterSpec(min: (double)(s.MinDecimal ?? s.MinInt.Value), max: (double)(s.MaxDecimal ?? s.MaxInt.Value),
transform: Transform.Linear, parameterType: s.Precision > 0 ? ParameterType.Continuous : ParameterType.Discrete)
).ToArray();
IOptimizer optimizer = null;
if (Config.Fitness != null)
{
if (Config.Fitness.OptimizerTypeName == Enums.OptimizerTypeOptions.RandomSearch.ToString())
{
optimizer = new RandomSearchOptimizer(parameters, iterations: Config.Generations, seed: 42, maxDegreeOfParallelism: Config.MaxThreads);
}
else if (Config.Fitness.OptimizerTypeName == Enums.OptimizerTypeOptions.ParticleSwarm.ToString())
{
optimizer = new ParticleSwarmOptimizer(parameters, maxIterations: Config.Generations, numberOfParticles: Config.PopulationSize,
seed: 42, maxDegreeOfParallelism: Config.MaxThreads);
}
else if (Config.Fitness.OptimizerTypeName == Enums.OptimizerTypeOptions.Bayesian.ToString())
{
optimizer = new BayesianOptimizer(parameters, maxIterations: Config.Generations, numberOfStartingPoints: Config.PopulationSize, seed: 42);
}
else if (Config.Fitness.OptimizerTypeName == Enums.OptimizerTypeOptions.GlobalizedBoundedNelderMead.ToString())
{
optimizer = new GlobalizedBoundedNelderMeadOptimizer(parameters, maxRestarts: Config.Generations,
maxIterationsPrRestart: Config.PopulationSize, seed: 42, maxDegreeOfParallelism: Config.MaxThreads);
}
else if (Config.Fitness.OptimizerTypeName == Enums.OptimizerTypeOptions.Genetic.ToString())
{
throw new Exception("Genetic optimizer cannot be used with Sharpe Maximizer");
}
}
//todo:
// GridSearchOptimizer?
Func <double[], OptimizerResult> minimize = p => Minimize(p, (Chromosome)chromosome);
// run optimizer
var result = optimizer.OptimizeBest(minimize);
Best = ToChromosome(result, chromosome);
return(result.Error);
}
catch (Exception ex)
{
Program.Logger.Error(ex);
return(ErrorFitness);
}
}
public async Task <IterationResult> Start(IOptimizerConfiguration config, CancellationToken cancellationToken)
{
CancellationToken = cancellationToken;
var parameters = config.Genes.Select(s =>
new MinMaxParameterSpec(min: s.Min ?? s.Actual.Value, max: s.Max ?? s.Actual.Value,
transform: Transform.Linear, parameterType: s.Precision > 0 ? ParameterType.Continuous : ParameterType.Discrete)
).ToArray();
Keys = config.Genes.Where(g => g.Key != "id").Select(s => s.Key);
IOptimizer optimizerMethod = null;
if (config.Fitness != null)
{
if (config.Fitness.OptimizerTypeName == Enums.OptimizerTypeOptions.RandomSearch.ToString())
{
optimizerMethod = new RandomSearchOptimizer(parameters, iterations: config.Generations, seed: 42, runParallel: false);
}
else if (config.Fitness.OptimizerTypeName == Enums.OptimizerTypeOptions.ParticleSwarm.ToString())
{
optimizerMethod = new ParticleSwarmOptimizer(parameters, maxIterations: config.Generations, numberOfParticles: config.PopulationSize,
seed: 42, maxDegreeOfParallelism: 1);
}
else if (config.Fitness.OptimizerTypeName == Enums.OptimizerTypeOptions.Bayesian.ToString())
{
optimizerMethod = new BayesianOptimizer(parameters: parameters, iterations: config.Generations, randomStartingPointCount: config.PopulationSize,
functionEvaluationsPerIterationCount: config.PopulationSize, seed: 42, runParallel: false);
}
else if (config.Fitness.OptimizerTypeName == Enums.OptimizerTypeOptions.GlobalizedBoundedNelderMead.ToString())
{
optimizerMethod = new GlobalizedBoundedNelderMeadOptimizer(parameters, maxRestarts: config.Generations,
maxIterationsPrRestart: config.PopulationSize, seed: 42, maxDegreeOfParallelism: 1);
}
else if (config.Fitness.OptimizerTypeName == Enums.OptimizerTypeOptions.GridSearch.ToString())
{
optimizerMethod = new GridSearchOptimizer(config.Genes.Select(s => new GridParameterSpec(RangeWithPrecision.Range(s.Min.Value, s.Max.Value, s.Precision.Value).ToArray())).ToArray(), runParallel: false);
}
}
else
{
throw new ArgumentException("No optimizer was configured.");
}
var result = await optimizerMethod.OptimizeBest(Minimize);
return(new IterationResult {
ParameterSet = result.ParameterSet, Cost = IsMaximizing ? result.Error * -1 : result.Error
});
}
public void ParticleSwarmOptimizer_OptimizeBest()
{
var parameters = new ParameterBounds[]
{
new ParameterBounds(-10.0, 10.0, Transform.Linear),
new ParameterBounds(-10.0, 10.0, Transform.Linear),
new ParameterBounds(-10.0, 10.0, Transform.Linear),
};
var sut = 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 ParticleSwarmOptimizer_OptimizeBest()
{
var parameters = new double[][]
{
new double[] { -10.0, 10.0 },
new double[] { -10.0, 10.0 },
new double[] { -10.0, 10.0 }
};
var sut = new ParticleSwarmOptimizer(parameters, 100);
var actual = sut.OptimizeBest(Minimize);
Assert.AreEqual(actual.Error, -0.38111188515223809, 0.0000001);
Assert.AreEqual(actual.ParameterSet.Length, 3);
Assert.AreEqual(actual.ParameterSet[0], 10, 0.0000001);
Assert.AreEqual(actual.ParameterSet[1], 0.003223641308240488, 0.0000001);
Assert.AreEqual(actual.ParameterSet[2], 0.42745032466778454, 0.0000001);
}
public void ParticleSwarmOptimizer_OptimizeBest()
{
var parameters = new ParameterBounds[]
{
new ParameterBounds(-10.0, 10.0, Transform.Linear),
new ParameterBounds(-10.0, 10.0, Transform.Linear),
new ParameterBounds(-10.0, 10.0, Transform.Linear),
};
var sut = new ParticleSwarmOptimizer(parameters, 100);
var actual = sut.OptimizeBest(Minimize);
Assert.AreEqual(actual.Error, -0.45484916939206588, 0.0000001);
Assert.AreEqual(actual.ParameterSet.Length, 3);
Assert.AreEqual(actual.ParameterSet[0], -10, 0.0000001);
Assert.AreEqual(actual.ParameterSet[1], -10, 0.0000001);
Assert.AreEqual(actual.ParameterSet[2], 0.0035692182837614439, 0.0000001);
}
public void ParticleSwarmOptimizer_Optimize()
{
var parameters = new double[][] { new double[] { 0.0, 100.0 } };
var sut = 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[] { 37.635959742891046 }, 109.58839344747747),
new OptimizerResult(new double[] { 38.891904333594624 }, 166.38611320480345)
};
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);
}
static ParticleSwarmOptimizer CreateSut(
int?maybeMaxDegreeOfParallelism,
MinMaxParameterSpec[] parameters)
{
const int DefaultMaxDegreeOfParallelism = -1;
var maxDegreeOfParallelism = maybeMaxDegreeOfParallelism.HasValue ?
maybeMaxDegreeOfParallelism.Value : DefaultMaxDegreeOfParallelism;
var sut = new ParticleSwarmOptimizer(parameters,
maxIterations: 100,
numberOfParticles: 10,
c1: 2,
c2: 2,
seed: 42,
maxDegreeOfParallelism: maxDegreeOfParallelism);
return(sut);
}
public void ParticleSwarmOptimizer_Optimize()
{
var parameters = new ParameterBounds[]
{
new ParameterBounds(0.0, 100.0, Transform.Linear)
};
var sut = 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[] { 37.660092259635064 }, 109.45936368750877),
new OptimizerResult(new double[] { 39.038272502859328 }, 181.43166846962754)
};
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 ParticleSwarmOptimizer_Optimize()
{
var parameters = new ParameterBounds[]
{
new ParameterBounds(0.0, 100.0, Transform.Linear)
};
var sut = 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[] { 37.804275358363732 }, 109.68474734728727),
new OptimizerResult(new double[] { 35.942821697748165 }, 238.00642904844648)
};
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 override double Evaluate(IChromosome chromosome)
{
try
{
var parameters = Config.Genes.Select(s =>
new MinMaxParameterSpec(min: s.Min ?? s.Actual.Value, max: s.Max ?? s.Actual.Value,
transform: Transform.Linear, parameterType: s.Precision > 0 ? ParameterType.Continuous : ParameterType.Discrete)
).ToArray();
IOptimizer optimizer = null;
if (Config.Fitness != null)
{
if (Config.Fitness.OptimizerTypeName == Enums.OptimizerTypeOptions.RandomSearch.ToString())
{
optimizer = new RandomSearchOptimizer(parameters, iterations: Config.Generations, seed: Seed, maxDegreeOfParallelism: Config.MaxThreads);
}
else if (Config.Fitness.OptimizerTypeName == Enums.OptimizerTypeOptions.ParticleSwarm.ToString())
{
optimizer = new ParticleSwarmOptimizer(parameters, maxIterations: Config.Generations, numberOfParticles: Config.PopulationSize,
seed: Seed, maxDegreeOfParallelism: Config.MaxThreads);
}
else if (Config.Fitness.OptimizerTypeName == Enums.OptimizerTypeOptions.Bayesian.ToString())
{
optimizer = new BayesianOptimizer(parameters: parameters, iterations: Config.Generations, randomStartingPointCount: Config.PopulationSize,
functionEvaluationsPerIterationCount: Config.PopulationSize, seed: Seed);
//optimizer = new BayesianOptimizer(parameters, iterations: Config.Generations, randomStartingPointCount: Config.PopulationSize,
// functionEvaluationsPerIteration: Config.MaxThreads, seed: 42, maxDegreeOfParallelism: Config.MaxThreads, allowMultipleEvaluations: true);
}
else if (Config.Fitness.OptimizerTypeName == Enums.OptimizerTypeOptions.GlobalizedBoundedNelderMead.ToString())
{
optimizer = new GlobalizedBoundedNelderMeadOptimizer(parameters, maxRestarts: Config.Generations,
maxIterationsPrRestart: Config.PopulationSize, seed: Seed, maxDegreeOfParallelism: Config.MaxThreads);
}
else if (Config.Fitness.OptimizerTypeName == Enums.OptimizerTypeOptions.Smac.ToString())
{
optimizer = new SmacOptimizer(parameters, iterations: Config.Generations, randomStartingPointCount: Config.PopulationSize, seed: 42,
functionEvaluationsPerIterationCount: Config.MaxThreads);
}
else if (Config.Fitness.OptimizerTypeName == Enums.OptimizerTypeOptions.GridSearch.ToString())
{
optimizer = new GridSearchOptimizer(parameters);
}
else if (Config.Fitness.OptimizerTypeName == Enums.OptimizerTypeOptions.Genetic.ToString())
{
throw new Exception("Genetic optimizer cannot be used with Sharpe Maximizer");
}
}
else
{
throw new ArgumentException("No fitness section was configured.");
}
Func <double[], OptimizerResult> minimize = p => Minimize(p, (Chromosome)chromosome);
var result = optimizer.OptimizeBest(minimize);
Best = MergeFromResult(result, chromosome);
return(result.Error);
}
catch (Exception ex)
{
LogProvider.ErrorLogger.Error(ex);
return(ErrorFitness);
}
}
