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);
}
