public Dictionary <int, DateTime[]> Calculate(IOptimizerConfiguration config)
{
var startDate = config.StartDate.Value.Date;
var endDate = config.EndDate.Value.Date;
return(Calculate(config.Fitness.Folds, startDate, endDate));
}
public Dictionary <string, string> Run(Dictionary <string, object> items)
{
string plain = string.Join(",", items.Select(s => s.Value));
Dictionary <string, Dictionary <string, string> > results = AppDomainManager.GetResults(AppDomain.CurrentDomain);
_config = AppDomainManager.GetConfig(AppDomain.CurrentDomain);
if (results.ContainsKey(plain))
{
return(results[plain]);
}
foreach (var pair in items)
{
Config.Set(pair.Key, pair.Value.ToString());
}
LaunchLean();
results.Add(plain, _resultsHandler.FinalStatistics);
AppDomainManager.SetResults(AppDomain.CurrentDomain, results);
return(_resultsHandler.FinalStatistics);
}
public static void Initialize(IOptimizerConfiguration config)
{
_config = config;
_results = new Dictionary <string, Dictionary <string, decimal> >();
_ads = SetupAppDomain();
_resultsLocker = new object();
}
public IWalkForwardSharpeMaximizer Create(IOptimizerConfiguration config, IFitnessFilter filter)
{
var mock = new Mock <IWalkForwardSharpeMaximizer>();
mock.Setup(m => m.Evaluate(It.IsAny <IChromosome>())).Returns(2);
var allBest = new List <Dictionary <string, object> > {
new Dictionary <string, object> {
{ "p1", 0.1 }, { "p2", 10.0 }
}, new Dictionary <string, object> {
{ "p1", 0.2 }, { "p2", 11.0 }
}
};
mock.Setup(m => m.AllBest).Returns(allBest);
var allScores = new List <FitnessResult> {
new FitnessResult {
Fitness = 1, Value = 2
}, new FitnessResult {
Fitness = 2, Value = 3
}
};
mock.Setup(m => m.AllScores).Returns(allScores);
return(mock.Object);
}
public Dictionary <string, decimal> Run(Dictionary <string, object> items, IOptimizerConfiguration config)
{
Dictionary <string, Dictionary <string, decimal> > results = OptimizerAppDomainManager.GetResults(AppDomain.CurrentDomain);
_config = config;
_id = (items.ContainsKey("Id") ? items["Id"] : Guid.NewGuid()).ToString();
if (_config.StartDate.HasValue && _config.EndDate.HasValue)
{
if (!items.ContainsKey("startDate"))
{
items.Add("startDate", _config.StartDate);
}
if (!items.ContainsKey("endDate"))
{
items.Add("endDate", _config.EndDate);
}
}
string jsonKey = JsonConvert.SerializeObject(items);
if (results.ContainsKey(jsonKey))
{
return(results[jsonKey]);
}
//just ignore id gene
foreach (var pair in items.Where(i => i.Key != "Id"))
{
if (pair.Value is DateTime?)
{
var cast = ((DateTime?)pair.Value);
if (cast.HasValue)
{
Config.Set(pair.Key, cast.Value.ToString("O"));
}
}
else
{
Config.Set(pair.Key, pair.Value.ToString());
}
}
if (EngineContext.SystemHandlers == null || EngineContext.Engine == null)
{
LaunchLean();
}
RunJob();
if (_resultsHandler.FullResults != null && _resultsHandler.FullResults.Any())
{
results.Add(jsonKey, _resultsHandler.FullResults);
OptimizerAppDomainManager.SetResults(AppDomain.CurrentDomain, results);
}
return(_resultsHandler.FullResults);
}
public Dictionary <string, decimal> Run(Dictionary <string, object> items, IOptimizerConfiguration config)
{
Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory);
_config = config;
var id = (items.ContainsKey("Id") ? items["Id"] : Guid.NewGuid().ToString("N")).ToString();
if (_config.StartDate.HasValue && _config.EndDate.HasValue)
{
if (!items.ContainsKey("startDate"))
{
items.Add("startDate", _config.StartDate);
}
if (!items.ContainsKey("endDate"))
{
items.Add("endDate", _config.EndDate);
}
}
string jsonKey = JsonConvert.SerializeObject(items.Where(i => i.Key != "Id"));
if (!_config.EnableRunningDuplicateParameters && GetResults().ContainsKey(jsonKey))
{
return(GetResults()[jsonKey]);
}
var filteredConfig = new Dictionary <string, object>();
//just ignore id gene
foreach (var pair in items.Where(i => i.Key != "Id"))
{
if (pair.Value is DateTime?)
{
var cast = ((DateTime?)pair.Value);
if (cast.HasValue)
{
filteredConfig.Add(pair.Key, cast.Value.ToString("O"));
}
}
else
{
filteredConfig.Add(pair.Key, pair.Value.ToString());
}
}
//store uniquely keyed config in app domain for each algorithm instance
//todo: cleanup
ResultMediator.SetData(AppDomain.CurrentDomain, id, filteredConfig);
LogProvider.TraceLogger.Trace($"id: {id} started.");
LaunchLean(id);
LogProvider.TraceLogger.Trace($"id: {id} finished.");
AddToResults(config, jsonKey);
return(_resultsHandler.FullResults);
}
public WalkForwardWeightedMetricSharpeMaximizer(IOptimizerConfiguration config, IFitnessFilter filter) : base(config, filter)
{
//one thread for parent and max threads for fold optimizer
_foldMaxThreads = config.MaxThreads;
config.MaxThreads = 1;
WalkForwardSharpeMaximizerFactory = new WalkForwardSharpeMaximizerFactory();
}
public NFoldCrossSharpeMaximizer(IOptimizerConfiguration config, IFitnessFilter filter) : base(config, filter)
{
var folds = config.Fitness?.Folds ?? 2;
if (folds > 0)
{
_folds = folds;
}
}
public WalkForwardSharpeMaximizer(IOptimizerConfiguration config, IFitnessFilter filter) : base(config, filter)
{
if (config.Fitness == null)
{
config.Fitness = new FitnessConfiguration {
OptimizerTypeName = Enums.OptimizerTypeOptions.RandomSearch.ToString()
};
}
config.Fitness.Folds = config.Fitness?.Folds ?? 2;
}
public void Initialize(IOptimizerConfiguration config, OptimizerFitness fitness)
{
_config = config;
_fitness = fitness;
_executor = new SmartThreadPoolTaskExecutor()
{
MinThreads = 1
};
_executor.MaxThreads = _config.MaxThreads > 0 ? _config.MaxThreads : 8;
}
public NFoldCrossSharpeMaximizer(IOptimizerConfiguration config, IFitnessFilter filter) : base(config, filter)
{
var folds = config.Fitness?.Folds ?? 2;
if (folds > 0)
{
_folds = folds;
}
if (config.EndDate == null || config.StartDate == null)
{
throw new ArgumentException("Must supply start and end dates");
}
}
public Dictionary <string, decimal> Run(Dictionary <string, object> items)
{
Dictionary <string, Dictionary <string, decimal> > results = OptimizerAppDomainManager.GetResults(AppDomain.CurrentDomain);
_config = OptimizerAppDomainManager.GetConfig(AppDomain.CurrentDomain);
_id = (items.ContainsKey("Id") ? items["Id"] : Guid.NewGuid()).ToString();
items.Remove("Id");
if (_config.StartDate.HasValue && _config.EndDate.HasValue)
{
if (!items.ContainsKey("startDate"))
{
items.Add("startDate", _config.StartDate);
}
if (!items.ContainsKey("endDate"))
{
items.Add("endDate", _config.EndDate);
}
}
string plain = string.Join(",", items.Select(s => s.Value));
if (results.ContainsKey(plain))
{
return(results[plain]);
}
foreach (var pair in items)
{
if (pair.Value is DateTime?)
{
var cast = ((DateTime?)pair.Value);
if (cast.HasValue)
{
Config.Set(pair.Key, cast.Value.ToString("O"));
}
}
else
{
Config.Set(pair.Key, pair.Value.ToString());
}
}
LaunchLean();
results.Add(plain, _resultsHandler.FullResults);
OptimizerAppDomainManager.SetResults(AppDomain.CurrentDomain, results);
return(_resultsHandler.FullResults);
}
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 ConfiguredFitness(IOptimizerConfiguration config) : base(config)
{
if (config.Fitness == null)
{
throw new ArgumentException("No fitness configuration was found.");
}
if (!config.Fitness.Scale.HasValue)
{
config.Fitness.Scale = 1;
}
if (!config.Fitness.Modifier.HasValue)
{
config.Fitness.Modifier = 1;
}
this.Name = Config.Fitness.Name;
}
public static void Merge(IOptimizerConfiguration config, string id, Type runnerType)
{
Config.Set("environment", "backtesting");
if (!string.IsNullOrEmpty(config.AlgorithmTypeName))
{
Config.Set("algorithm-type-name", config.AlgorithmTypeName);
}
if (!string.IsNullOrEmpty(config.AlgorithmLocation))
{
Config.Set("algorithm-location", config.AlgorithmLocation);
}
if (!string.IsNullOrEmpty(config.AlgorithmLanguage))
{
Config.Set("algorithm-language", config.AlgorithmLanguage);
}
if (!string.IsNullOrEmpty(config.DataFolder))
{
Config.Set("data-folder", config.DataFolder);
}
//override config to use custom result handler
Config.Set("backtesting.result-handler", nameof(OptimizerResultHandler));
if (runnerType == typeof(SingleRunner))
{
Config.Set("backtesting.history-provider", nameof(OptimizerSubscriptionDataReaderHistoryProvider));
Config.Set("api-handler", nameof(EmptyApiHandler));
}
//todo: transaction log
if (!string.IsNullOrEmpty(config.TransactionLog))
{
var filename = config.TransactionLog;
filename = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, Path.GetFileNameWithoutExtension(filename) + id + Path.GetExtension(filename));
Config.Set("transaction-log", filename);
}
}
public Wrapper(IOptimizerConfiguration config) : base(config, null)
{
//the in sample mock records the chromosome passed in and returns best genes with incremented actual values
Mock <SharpeMaximizer> inSampleMaximizer = null;
_factory.Setup(m => m.Create(It.IsAny <IOptimizerConfiguration>(), It.IsAny <IFitnessFilter>())).Returns <IOptimizerConfiguration, IFitnessFilter>((o, f) =>
{
inSampleMaximizer = new Mock <SharpeMaximizer>(o, null);
inSampleMaximizer.Setup(m => m.Evaluate(It.IsAny <IChromosome>())).Callback <IChromosome>(c =>
{
ActualInSampleChromosome.Add((Chromosome)c);
}).Returns(1);
ActualInSampleConfig.Add(o);
inSampleMaximizer.Setup(m => m.Best).Returns(new Chromosome(true, SetupBestGenes()));
return(inSampleMaximizer.Object);
});
}
private void AddToResults(IOptimizerConfiguration config, string jsonKey)
{
lock (_resultsLocker)
{
//for multiple runs, keep most recent only
if (config.EnableRunningDuplicateParameters)
{
if (GetResults().ContainsKey(jsonKey))
{
GetResults().Remove(jsonKey);
}
GetResults().Add(jsonKey, _resultsHandler.FullResults);
}
else
{
if (!GetResults().ContainsKey(jsonKey))
{
GetResults().Add(jsonKey, _resultsHandler.FullResults);
}
}
}
}
public OptimizerFitness(IOptimizerConfiguration config)
{
_config = config;
}
const int days = 250; // trading days for annualization
#endregion
public DeflatedSharpeRatioFitness(IOptimizerConfiguration config, IFitnessFilter filter) : base(config, filter)
{
}
public Dictionary <string, decimal> Run(Dictionary <string, object> items, IOptimizerConfiguration config)
{
Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory);
Dictionary <string, Dictionary <string, decimal> > results = ResultMediator.GetResults(AppDomain.CurrentDomain);
_config = config;
_id = (items.ContainsKey("Id") ? items["Id"] : Guid.NewGuid().ToString("N")).ToString();
if (_config.StartDate.HasValue && _config.EndDate.HasValue)
{
if (!items.ContainsKey("startDate"))
{
items.Add("startDate", _config.StartDate);
}
if (!items.ContainsKey("endDate"))
{
items.Add("endDate", _config.EndDate);
}
}
string jsonKey = JsonConvert.SerializeObject(items.Where(i => i.Key != "Id"));
if (!config.EnableRunningDuplicateParameters && results.ContainsKey(jsonKey))
{
return(results[jsonKey]);
}
//just ignore id gene
foreach (var pair in items.Where(i => i.Key != "Id"))
{
if (pair.Value is DateTime?)
{
var cast = ((DateTime?)pair.Value);
if (cast.HasValue)
{
Config.Set(pair.Key, cast.Value.ToString("O"));
}
}
else
{
Config.Set(pair.Key, pair.Value.ToString());
}
}
LogProvider.TraceLogger.Trace($"id: {_id} started.");
LaunchLean();
LogProvider.TraceLogger.Trace($"id: {_id} finished.");
if (_resultsHandler.FullResults != null && _resultsHandler.FullResults.Any())
{
if (config.EnableRunningDuplicateParameters && results.ContainsKey(jsonKey))
{
results.Remove(jsonKey);
}
results.Add(jsonKey, _resultsHandler.FullResults);
ResultMediator.SetResults(AppDomain.CurrentDomain, results);
}
return(_resultsHandler.FullResults);
}
public SharpeMaximizer(IOptimizerConfiguration config, IFitnessFilter filter) : base(config, filter)
{
_resultIndex = new ConditionalWeakTable <OptimizerResult, string>();
}
public virtual Dictionary <string, decimal> RunAlgorithm(Dictionary <string, object> list, IOptimizerConfiguration config)
{
if (config.UseSharedAppDomain)
{
return(SingleAppDomainManager.RunAlgorithm(list, config));
}
else
{
return(OptimizerAppDomainManager.RunAlgorithm(list, config));
}
}
public virtual Dictionary <string, decimal> GetScore(Dictionary <string, object> list, IOptimizerConfiguration config)
{
return(RunAlgorithm(list, config));
}
public TotalTradesFitness(IOptimizerConfiguration config) : base(config)
{
}
public GeneManager(IOptimizerConfiguration config, OptimizerFitness fitness)
{
_config = config;
_fitness = fitness;
}
public OptimizerFitness(IOptimizerConfiguration config, IFitnessFilter filter)
{
Config = config;
Filter = filter;
}
public SharpeMaximizer Create(IOptimizerConfiguration config, IFitnessFilter filter)
{
return(new SharpeMaximizer(config, filter));
}
public AdaptiveSharpeRatioFitness(IOptimizerConfiguration config, IFitnessFilter filter) : base(config, filter)
{
}
public CompoundingAnnualReturnFitness(IOptimizerConfiguration config) : base(config)
{
}
public DualPeriodSharpeFitness(IOptimizerConfiguration config) : base(config)
{
}
