public void RoundTrip(string strategyName, Type settingType) { var optimizationNodePacket = new OptimizationNodePacket() { CompileId = Guid.NewGuid().ToString(), OptimizationId = Guid.NewGuid().ToString(), OptimizationStrategy = strategyName, Criterion = new Target("Profit", new Maximization(), 100.5m), Constraints = new List <Constraint> { new Constraint("Drawdown", ComparisonOperatorTypes.LessOrEqual, 0.1m), new Constraint("Profit", ComparisonOperatorTypes.Greater, 100) }, OptimizationParameters = new HashSet <OptimizationParameter>() { new OptimizationStepParameter("ema-slow", 1, 100, 1m), new OptimizationStepParameter("ema-fast", -10, 0, 0.5m) }, MaximumConcurrentBacktests = 10, OptimizationStrategySettings = (OptimizationStrategySettings)Activator.CreateInstance(settingType) }; var serialize = JsonConvert.SerializeObject(optimizationNodePacket, _jsonSettings); var result = JsonConvert.DeserializeObject <OptimizationNodePacket>(serialize, _jsonSettings); // common Assert.AreEqual(PacketType.OptimizationNode, result.Type); // assert strategy Assert.AreEqual(optimizationNodePacket.OptimizationStrategy, result.OptimizationStrategy); Assert.AreEqual(optimizationNodePacket.OptimizationId, result.OptimizationId); Assert.AreEqual(optimizationNodePacket.CompileId, result.CompileId); // assert optimization parameters foreach (var expected in optimizationNodePacket.OptimizationParameters.OfType <OptimizationStepParameter>()) { var actual = result.OptimizationParameters.FirstOrDefault(s => s.Name == expected.Name) as OptimizationStepParameter; Assert.NotNull(actual); Assert.AreEqual(expected.MinValue, actual.MinValue); Assert.AreEqual(expected.MaxValue, actual.MaxValue); Assert.AreEqual(expected.Step, actual.Step); } // assert target Assert.AreEqual(optimizationNodePacket.Criterion.Target, result.Criterion.Target); Assert.AreEqual(optimizationNodePacket.Criterion.Extremum.GetType(), result.Criterion.Extremum.GetType()); Assert.AreEqual(optimizationNodePacket.Criterion.TargetValue, result.Criterion.TargetValue); // assert constraints foreach (var expected in optimizationNodePacket.Constraints) { var actual = result.Constraints.FirstOrDefault(s => s.Target == expected.Target); Assert.NotNull(actual); Assert.AreEqual(expected.Operator, actual.Operator); Assert.AreEqual(expected.TargetValue, actual.TargetValue); } // others Assert.AreEqual(optimizationNodePacket.MaximumConcurrentBacktests, result.MaximumConcurrentBacktests); Assert.AreEqual(settingType, result.OptimizationStrategySettings.GetType()); }
public static void Main() { var endedEvent = new ManualResetEvent(false); try { Log.DebuggingEnabled = Config.GetBool("debug-mode"); Log.FilePath = Path.Combine(Config.Get("results-destination-folder"), "log.txt"); Log.LogHandler = Composer.Instance.GetExportedValueByTypeName <ILogHandler>(Config.Get("log-handler", "CompositeLogHandler")); var optimizationStrategyName = Config.Get("optimization-strategy", "QuantConnect.Optimizer.GridSearchOptimizationStrategy"); var packet = new OptimizationNodePacket { OptimizationId = Guid.NewGuid().ToString(), OptimizationStrategy = optimizationStrategyName, OptimizationStrategySettings = (OptimizationStrategySettings)JsonConvert.DeserializeObject(Config.Get( "optimization-strategy-settings", "{\"$type\":\"QuantConnect.Optimizer.Strategies.OptimizationStrategySettings, QuantConnect.Optimizer\"}"), new JsonSerializerSettings() { TypeNameHandling = TypeNameHandling.All }), Criterion = JsonConvert.DeserializeObject <Target>(Config.Get("optimization-criterion", "{\"target\":\"Statistics.TotalProfit\", \"extremum\": \"max\"}")), Constraints = JsonConvert.DeserializeObject <List <Constraint> >(Config.Get("constraints", "[]")).AsReadOnly(), OptimizationParameters = JsonConvert.DeserializeObject <HashSet <OptimizationParameter> >(Config.Get("parameters", "[]")), MaximumConcurrentBacktests = Config.GetInt("maximum-concurrent-backtests", Environment.ProcessorCount / 2) }; var optimizer = new ConsoleLeanOptimizer(packet); optimizer.Start(); optimizer.Ended += (s, e) => { optimizer.DisposeSafely(); endedEvent.Set(); }; } catch (Exception e) { Log.Error(e); } // Wait until the optimizer has stopped running before exiting endedEvent.WaitOne(); }
public void MaximizeEulerWithConstraints() { var resetEvent = new ManualResetEvent(false); var packet = new OptimizationNodePacket { OptimizationStrategy = "QuantConnect.Optimizer.Strategies.EulerSearchOptimizationStrategy", Criterion = new Target("Profit", new Maximization(), null), OptimizationParameters = new HashSet <OptimizationParameter> { new OptimizationStepParameter("ema-slow", 1, 10, 1), new OptimizationStepParameter("ema-fast", 10, 100, 10m, 0.1m) }, Constraints = new List <Constraint> { new Constraint("Drawdown", ComparisonOperatorTypes.LessOrEqual, 0.15m) }, MaximumConcurrentBacktests = 20, OptimizationStrategySettings = new StepBaseOptimizationStrategySettings { DefaultSegmentAmount = 10 } }; var optimizer = new FakeLeanOptimizer(packet); OptimizationResult result = null; optimizer.Ended += (s, solution) => { result = solution; optimizer.DisposeSafely(); resetEvent.Set(); }; optimizer.Start(); resetEvent.WaitOne(); Assert.NotNull(result); Assert.AreEqual( 15, JsonConvert.DeserializeObject <BacktestResult>(result.JsonBacktestResult).Statistics.Profit); Assert.AreEqual( 0.15m, JsonConvert.DeserializeObject <BacktestResult>(result.JsonBacktestResult).Statistics.Drawdown); }
public void MaximizeNoTarget(string strategyName) { var resetEvent = new ManualResetEvent(false); var packet = new OptimizationNodePacket { OptimizationStrategy = strategyName, Criterion = new Target("Profit", new Maximization(), null), OptimizationParameters = new HashSet <OptimizationParameter> { new OptimizationStepParameter("ema-slow", 1, 10, 1), new OptimizationStepParameter("ema-fast", 10, 100, 3) }, MaximumConcurrentBacktests = 20, OptimizationStrategySettings = new StepBaseOptimizationStrategySettings { DefaultSegmentAmount = 10 } }; var optimizer = new FakeLeanOptimizer(packet); OptimizationResult result = null; optimizer.Ended += (s, solution) => { result = solution; optimizer.DisposeSafely(); resetEvent.Set(); }; optimizer.Start(); resetEvent.WaitOne(); Assert.NotNull(result); Assert.AreEqual( 110, JsonConvert.DeserializeObject <BacktestResult>(result.JsonBacktestResult).Statistics.Profit); Assert.AreEqual(10, result.ParameterSet.Value["ema-slow"].ToDecimal()); Assert.AreEqual(100, result.ParameterSet.Value["ema-fast"].ToDecimal()); }
public void MinimizeWithTargetAndConstraints() { var resetEvent = new ManualResetEvent(false); var packet = new OptimizationNodePacket { Criterion = new Target("Profit", new Minimization(), 20), OptimizationParameters = new HashSet <OptimizationParameter> { new OptimizationStepParameter("ema-slow", 1, 10, 1), new OptimizationStepParameter("ema-fast", 10, 100, 3) }, Constraints = new List <Constraint> { new Constraint("Drawdown", ComparisonOperatorTypes.LessOrEqual, 0.15m) }, MaximumConcurrentBacktests = 20 }; var optimizer = new FakeLeanOptimizer(packet); OptimizationResult result = null; optimizer.Ended += (s, solution) => { result = solution; optimizer.DisposeSafely(); resetEvent.Set(); }; optimizer.Start(); resetEvent.WaitOne(); Assert.NotNull(result); Assert.GreaterOrEqual( 20, JsonConvert.DeserializeObject <BacktestResult>(result.JsonBacktestResult).Statistics.Profit); Assert.GreaterOrEqual( 0.15m, JsonConvert.DeserializeObject <BacktestResult>(result.JsonBacktestResult).Statistics.Drawdown); }
/// <summary> /// Creates a new instance /// </summary> /// <param name="nodePacket">The optimization node packet to handle</param> public ConsoleLeanOptimizer(OptimizationNodePacket nodePacket) : base(nodePacket) { _processByBacktestId = new ConcurrentDictionary <string, Process>(); _rootResultDirectory = Configuration.Config.Get("results-destination-folder", Path.Combine(Directory.GetCurrentDirectory(), $"opt-{nodePacket.OptimizationId}")); Directory.CreateDirectory(_rootResultDirectory); _leanLocation = Configuration.Config.Get("lean-binaries-location", Path.Combine(Directory.GetCurrentDirectory(), "../../../Launcher/bin/Debug/QuantConnect.Lean.Launcher")); var closeLeanAutomatically = Configuration.Config.GetBool("optimizer-close-automatically", true); _extraLeanArguments = $"--close-automatically {closeLeanAutomatically}"; var algorithmTypeName = Configuration.Config.Get("algorithm-type-name"); if (!string.IsNullOrEmpty(algorithmTypeName)) { _extraLeanArguments += $" --algorithm-type-name \"{algorithmTypeName}\""; } var algorithmLanguage = Configuration.Config.Get("algorithm-language"); if (!string.IsNullOrEmpty(algorithmLanguage)) { _extraLeanArguments += $" --algorithm-language \"{algorithmLanguage}\""; } var algorithmLocation = Configuration.Config.Get("algorithm-location"); if (!string.IsNullOrEmpty(algorithmLocation)) { _extraLeanArguments += $" --algorithm-location \"{algorithmLocation}\""; } }
public void TrackEstimation() { Config.Set("optimization-update-interval", 1); OptimizationResult result = null; var resetEvent = new ManualResetEvent(false); var packet = new OptimizationNodePacket { Criterion = new Target("Profit", new Minimization(), null), OptimizationParameters = new HashSet <OptimizationParameter> { new OptimizationStepParameter("ema-slow", 1, 10, 1), new OptimizationStepParameter("ema-fast", 10, 100, 10) }, Constraints = new List <Constraint> { new Constraint("Drawdown", ComparisonOperatorTypes.LessOrEqual, 0.15m) }, MaximumConcurrentBacktests = 5 }; var optimizer = new FakeLeanOptimizer(packet); // keep stats up-to-date int totalBacktest = optimizer.GetCurrentEstimate(); int totalUpdates = 0; int completedTests = 0; int failed = 0; optimizer.Update += (s, e) => { var runtimeStats = optimizer.GetRuntimeStatistics(); Assert.LessOrEqual(int.Parse(runtimeStats["Running"], CultureInfo.InvariantCulture), packet.MaximumConcurrentBacktests); Assert.LessOrEqual(completedTests, int.Parse(runtimeStats["Completed"], CultureInfo.InvariantCulture)); Assert.LessOrEqual(failed, int.Parse(runtimeStats["Failed"], CultureInfo.InvariantCulture)); Assert.AreEqual(totalBacktest, optimizer.GetCurrentEstimate()); completedTests = int.Parse(runtimeStats["Completed"], CultureInfo.InvariantCulture); failed = int.Parse(runtimeStats["Failed"], CultureInfo.InvariantCulture); if (completedTests > 0) { // 'ms' aren't stored so might be 0 Assert.GreaterOrEqual(TimeSpan.Parse(runtimeStats["Average Length"], CultureInfo.InvariantCulture), TimeSpan.Zero); } totalUpdates++; }; optimizer.Ended += (s, solution) => { result = solution; optimizer.DisposeSafely(); resetEvent.Set(); }; optimizer.Start(); resetEvent.WaitOne(); var runtimeStatistics = optimizer.GetRuntimeStatistics(); Assert.NotZero(int.Parse(runtimeStatistics["Completed"], CultureInfo.InvariantCulture)); Assert.NotZero(int.Parse(runtimeStatistics["Failed"], CultureInfo.InvariantCulture)); // we have 2 force updates at least, expect a few more over it. Assert.Greater(totalUpdates, 2); Assert.AreEqual(int.Parse(runtimeStatistics["Completed"], CultureInfo.InvariantCulture) + int.Parse(runtimeStatistics["Failed"], CultureInfo.InvariantCulture) + int.Parse(runtimeStatistics["Running"], CultureInfo.InvariantCulture), totalBacktest); }
public FakeLeanOptimizer(OptimizationNodePacket nodePacket) : base(nodePacket) { }
public void TrackEstimation() { Config.Set("optimization-update-interval", 1); OptimizationEstimate estimate = null; OptimizationResult result = null; var resetEvent = new ManualResetEvent(false); var packet = new OptimizationNodePacket { Criterion = new Target("Profit", new Minimization(), null), OptimizationParameters = new HashSet <OptimizationParameter> { new OptimizationStepParameter("ema-slow", 1, 10, 1), new OptimizationStepParameter("ema-fast", 10, 100, 3) }, Constraints = new List <Constraint> { new Constraint("Drawdown", ComparisonOperatorTypes.LessOrEqual, 0.15m) }, MaximumConcurrentBacktests = 5 }; var optimizer = new FakeLeanOptimizer(packet); // keep stats up-to-date int totalBacktest = optimizer.GetCurrentEstimate().TotalBacktest; int totalUpdates = 0; int completedTests = 0; int failed = 0; optimizer.Update += (s, e) => { estimate = optimizer.GetCurrentEstimate(); Assert.LessOrEqual(estimate.RunningBacktest, packet.MaximumConcurrentBacktests); Assert.LessOrEqual(completedTests, estimate.CompletedBacktest); Assert.LessOrEqual(failed, estimate.FailedBacktest); Assert.AreEqual(totalBacktest, estimate.TotalBacktest); completedTests = estimate.CompletedBacktest; failed = estimate.FailedBacktest; if (completedTests > 0) { Assert.Greater(estimate.AverageBacktest, TimeSpan.Zero); } totalUpdates++; }; optimizer.Ended += (s, solution) => { result = solution; estimate = optimizer.GetCurrentEstimate(); optimizer.DisposeSafely(); resetEvent.Set(); }; optimizer.Start(); resetEvent.WaitOne(); Assert.NotZero(estimate.CompletedBacktest); Assert.NotZero(estimate.FailedBacktest); // we have 2 force updates at least, expect a few more over it. Assert.Greater(totalUpdates, 2); Assert.AreEqual(estimate.CompletedBacktest + estimate.FailedBacktest + estimate.RunningBacktest, totalBacktest); }