Optimization

The process to set parameter values depends on the environment you use to write algorithms. See the tutorial in one of the following environments:

• Cloud Platform
• Local Platform
• LEAN CLI

To get a parameter value into your algorithm, call the GetParameterget_parameter method of the algorithm class.

// Get the parameter string-value with this matching key. 
// Project parameters are useful for optimization or securing variables outside the source-code.
var parameterValue = GetParameter("Parameter Name");

# Get the parameter string-value with this matching key. 
# Project parameters are useful for optimization or securing variables outside the source-code.
parameter_value = self.get_parameter("Parameter Name")

The GetParameterget_parameter method returns a string by default. If you provide a default parameter value, the method returns the parameter value as the same data type as the default value. If there are no parameters in your project that match the name you pass to the method and you provide a default value to the method, it returns the default value. The following table describes the arguments the GetParameterget_parameter method accepts:

The following example algorithm gets the values of parameters of each data type:

// Example to get the values of parameters of each data type:
namespace QuantConnect.Algorithm.CSharp
{
    public class ParameterizedAlgorithm : QCAlgorithm
    {
        public override void Initialize()
        {
            // Get the parameter value and return an integer.
            var intParameterValue = GetParameter("intParameterName", 100);

            // Get the parameter value and return a double.
            var doubleParameterValue = GetParameter("doubleParameterName", 0.95);

            // Get the parameter value and return a decimal.
            var decimalParameterValue = GetParameter("decimalParameterName", 0.05m);

            // Get the parameter value as a string.
            var stringParameterValue = GetParameter("parameterName", "defaultStringValue")

            // Cast the string to an integer.
            var castedParameterValue = Convert.ToInt32(stringParameterValue);
        }
    }
}

# Example to get the values of parameters of each data type:
class ParameterizedAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        # Get the parameter value and return an integer.
        int_parameter_value = self.get_parameter("int_parameter_name", 100)

        # Get the parameter value and return a double.
        float_parameter_value = self.get_parameter("float_parameter_name", 0.95)

        # Get the parameter value as a string.
        string_parameter_value = self.get_parameter("parameter_name", "default_string_value")

        # Cast the string to an integer.
        parameter_value = int(string_parameter_value)

Alternatively, you can use the Parameter(name) attribute on top of class fields or properties to set their values. If there are no parameters in your project that match the name you pass to the attribute and you provide a default value to the method, it returns the default value.

// Use the Parameter attribute to set field values externally, enabling flexible configuration with default fallback.
namespace QuantConnect.Algorithm.CSharp
{
    public class ParameterizedAlgorithm : QCAlgorithm
    {
        [Parameter("intParameterName")]
        public int IntParameterValue = 100;

        [Parameter("doubleParameterName")]
        public double DoubleParameterValue = 0.95;

        [Parameter("decimalParameterName")]
        public decimal DecimalParameterValue = 0.05m;
    }
}

The parameter values are sent to your algorithm when you deploy the algorithm, so it's not possible to change the parameter values while the algorithm runs.

Overfitting occurs when a function is fit too closely fit to a limited set of training data. Overfitting can occur in your trading algorithms if you have many parameters or select parameters values that worked very well in the past but are sensitive to small changes in their values. In these cases, your algorithm will likely be fine-tuned to fit the detail and noise of the historical data to the extent that it negatively impacts the live performance of your algorithm. The following image shows examples of underfit, optimally-fit, and overfit functions:

An algorithm that is dynamic and generalizes to new data is more likely to survive across different market conditions and apply to other markets.

Look-ahead bias occurs when an algorithm makes decisions using data that would not have yet been available. For instance, in optimization jobs, you optimize a set of parameters over a historical backtesting period. After the optimizer finds the optimal parameter values, the backtest period becomes part of the in-sample data. If you run a backtest over the same period using the optimal parameters, look-ahead bias has seeped into your research. In reality, it would not be possible to know the optimal parameters during the testing period until after the testing period is over. To avoid issues with look-ahead bias, optimize on older historical data and test the optimal parameter values on recent historical data. Alternatively, apply walk forward optimization to optimize the parameters on smaller batches of history.

To update parameters in live mode, add a Schedule Event that downloads a remote file and uses its contents to update the parameter values.

private Dictionary _parameters = new();
public override void Initialize()
{
    if (LiveMode)
    {
        Schedule.On(
            DateRules.EveryDay(),
            TimeRules.Every(TimeSpan.FromMinutes(1)),
            ()=>
            {
                var content = Download(urlToRemoteFile);
                // Convert content to _parameters
            });
    }
}

def initialize(self):
    self.parameters = { }
    if self.live_mode:
        def download_parameters():
            content = self.download(url_to_remote_file)
            # Convert content to self.parameters

        self.schedule.on(self.date_rules.every_day(), self.time_rules.every(timedelta(minutes=1)), download_parameters)

The following examples demonstrate common practices for using optimization parameters.

Example 1: Bond Candidate Selection

The following algorithm holds a 60/40 stock-bond portfolio rebalancing monthly. To select the best bond ETF to act as a proxy to trade bonds, we create a list of bond tickers and grid search the best using each to backtest. Using a bond-id parameter, which is an integer ranging from 0 to the list size - 1 with a step size of 1, we can perform optimization to test each of them.

public class OptimizationParameterAlgorithm : QCAlgorithm
{
    // A list of bond ETFs candidates to trade as bond proxies. 
    private static readonly List<string> _bondList = new()
    {
        "TLT", "IEF", "SHY", "VCSH", "VCLT"
    };
    private Symbol _spy, _bond;

    public override void Initialize()
    {
        SetStartDate(2023, 1, 1);
        SetEndDate(2024, 1, 1);

        // Get the bond candidate to be tested.
        var bondId = GetParameter("bond-id", 0);
        
        // Request SPY and the selected bond data for trading.
        _spy = AddEquity("SPY", Resolution.Minute).Symbol;
        _bond = AddEquity(_bondList[bondId], Resolution.Minute).Symbol;

        // Rebalance for a stock-bond portfolio monthly.
        Schedule.On(
            DateRules.MonthStart(_spy),
            TimeRules.AfterMarketOpen(_spy, 1),
            Rebalance
        );
    }

    private void Rebalance()
    {
        // Hold an all-weather stock-bond 60/40 portfolio.
        SetHoldings(_spy, 0.6m);
        SetHoldings(_bond, 0.4m);
    }
}

class OptimizationParameterAlgorithm(QCAlgorithm):
    # A list of bond ETFs as candidates to trade as bond proxies. 
    _bond_list = [
        "TLT", "IEF", "SHY", "VCSH", "VCLT"
    ]

    def initialize(self) -> None:
        self.set_start_date(2023, 1, 1)
        self.set_end_date(2024, 1, 1)
    
        # Get the bond candidate to be tested.
        bond_id = self.get_parameter("bond-id", 0)
    
        # Request SPY and the selected bond data for trading.
        self.spy = self.add_equity("SPY", Resolution.MINUTE).symbol
        self.bond = self.add_equity(self._bond_list[bond_id], Resolution.MINUTE).symbol
    
        # Rebalance for a stock-bond portfolio monthly.
        self.schedule.on(
            self.date_rules.month_start(self.spy),
            self.time_rules.after_market_open(self.spy, 1),
            self.rebalance
        )
    
    def rebalance(self) -> None:
        # Hold an all-weather stock-bond 60/40 portfolio.
        self.set_holdings(self.spy, 0.6)
        self.set_holdings(self.bond, 0.4)