QuantConnect Community

Short answer: No, assuming you mean sub-account.

On e.g. Oanda (and I think also IB) you can have multiple sub-accounts and run algos individually.

Furthermore, on Oanda I suspect you might actually be able to connect multiple algos to the same account but the behavior is generally undefined and depending on what your algos are doing.

I know I can place trades in an algo account on Oanda manually, for instance, providing the algo isn't trying to do things that conflict with the trade. (Including use of margin, buying/selling/analyzing quantity of overlapping securities, and things like that.) However, I wouldn't bother trying to run two algos in crude fashion like this due to unforeseen potential problems.

As far as I know IB is probably more restrictive and you won't be able to make duplicate connections without interfering with the already open connection.

What you can do is to combine two different algos in the same QCAlgorithm, but this requires extra coding and may be especially complicated in the case they trade the same securities. Maybe you can also combine alphas trivially this way, haven't checked.

Petter is right, you have to code one algorithm properly to trade multiple strategies simultaniously. Alpha streams can do it too but you have to make a custom portfolio construction model based on the signals from each one.

LukeI do you have an example of a custom portfolio construction model as you described?

It's nothing special really, it just takes the insights that dictate each allocation from each alpha and puts them in a table by symbol and source alpha model, then averages it, lastly it normalizes all the allocations to add up to 100%.

Example

• Alpha 1:
  • SPY .5
  • TLT .2
  • XLU .3
• Alpha 2: 
  • SPY 1.0
• Alpha 3:
  • TLT .5
• Average:
  • SPY = .5 + 1.0 + 0 / 3 = .5
  • TLT = .2 + 0 + .5 /3 = .2333
  • XLU = .3 + 0 + 0 / 3 = .1
• Normalized/rounded allocation:
  • SPY = .6
  • TLT = .28
  • XLU = .12

I'm sure the coding is awful but this is directly from my algorithm:

from clr import AddReference

AddReference("QuantConnect.Common")

AddReference("QuantConnect.Algorithm.Framework")



from QuantConnect import Resolution, Extensions

from QuantConnect.Algorithm.Framework.Alphas import InsightCollection, InsightDirection

from QuantConnect.Algorithm.Framework.Portfolio import PortfolioConstructionModel, PortfolioTarget

from itertools import groupby

from datetime import datetime

from pytz import utc

UTCMIN = datetime.min.replace(tzinfo=utc)



import numpy as np



class Insight_Weighted_Portfolio(PortfolioConstructionModel):



    def __init__(self, variables, resolution = Resolution.Daily, reserve = 0, leverage = 1.0, num_alphas = 1.0, normalize = False):

        

        self.insightCollection = InsightCollection()

        self.removedSymbols = []

        self.addedSymbols = []

        self.rebalancingTime = UTCMIN

        self.rebalancingPeriod = Extensions.ToTimeSpan(resolution)

        self.allocation = {}

        self.reserved = reserve

        self.max_leverage = leverage

        self.normalize = normalize

        self.num_alphas = num_alphas

        self.var = variables

        

        self.insight_list = []

        

        self.symbol_list = []



    def CreateTargets(self, algorithm, insights):

        targets = []

            

        self.insightCollection.AddRange(insights)

        

        # Create Sell target for each security that was removed from the universe

        if self.removedSymbols is not None:

            universeDeselectionTargets = [ PortfolioTarget(symbol, 0) for symbol in self.removedSymbols ]

            targets.extend(universeDeselectionTargets)

            self.removedSymbols = None

            

        if self.addedSymbols is not None:

            for symbol in self.addedSymbols:

                self.allocation[symbol] = {}

            self.addedSymbols = None

            

        #if algorithm.UtcTime <= self.rebalancingTime:

        if not self.var.rebalance:

            return targets

            

        # Get insight that haven't expired of each symbol that is still in the universe

        activeInsights = self.insightCollection.GetActiveInsights(algorithm.UtcTime)

        

        # Get the last generated active insight for each symbol

        lastActiveInsights = []

        for symbol, g in groupby(activeInsights, lambda x: x.Symbol):

            lastActiveInsights.append(sorted(g, key = lambda x: x.GeneratedTimeUtc)[-1])

            

        #Gets Adjusted Portfolio value

        port_value_adjusted = ((float(algorithm.Portfolio.TotalPortfolioValue)* self.max_leverage) - self.reserved)

        

        if float(algorithm.Portfolio.TotalPortfolioValue) > 0.0:

            max_leverage_adjusted = port_value_adjusted/float(algorithm.Portfolio.TotalPortfolioValue)

        else: 

            max_leverage_adjusted = 0.0

            

        for insight in lastActiveInsights:

            

            if insight in self.insight_list: 

                #continue

                pass

            

            #self.insight_list.append(insight)

            

            symbol = insight.Symbol

            alpha = insight.SourceModel

            if insight.Weight:

                allocation = insight.Weight

            else:

                allocation = 0

            

            #Calculate required rebalance amount for each allocation

            if self.num_alphas == 0:

                return targets

            else:

                goal_value = (port_value_adjusted * allocation / self.num_alphas)

            

            #Adjusted % allocation

            if float(algorithm.Portfolio.TotalPortfolioValue) == 0.0:

                return targets

            else:

                try:

                    self.allocation[symbol][alpha] = goal_value/float(algorithm.Portfolio.TotalPortfolioValue)

                except:

                    pass

                    #algorithm.Log(str(symbol) + " " + str(alpha))

        

        combined_weight = {}

        for symbol in self.allocation.keys():

            wt = sum(list(self.allocation[symbol].values()))

            combined_weight[symbol] = round(wt*200.0)/200.0

        

        #option to normalize target_portfolio to fill all availible leverage

        

        original_wt = sum(np.abs(list(combined_weight.values())))

        if original_wt == 0.0:

            factor = 0.0

        else:

            if self.normalize:

                factor = max_leverage_adjusted/original_wt

            elif original_wt > max_leverage_adjusted:

                factor = max_leverage_adjusted/original_wt

            else:

                factor = 1.0

                

                

            

        for symbol in combined_weight.keys():        

            combined_weight[symbol] = combined_weight[symbol]*factor

            

            if algorithm.Securities[symbol].Price == 0.0:

                continue

            

            

            target = PortfolioTarget.Percent(algorithm, symbol,  combined_weight[symbol])

            

            if target != None:

                targets.append(target)

                

                #Log final desired allocation

                if str(symbol) in self.var.assets_Leveraged:

                    continue

                algorithm.Log(str(symbol) + " : " + str(round(combined_weight[symbol]*100,1)) + "% = " + str(int(target.Quantity)) + " shares.")

            

            else:

                pass

                #algorithm.Debug("Target Error on " + str(symbol) + ". Should be " + str(round(combined_weight[symbol]*100,1)) + "%")

                

        #self.rebalancingTime = algorithm.UtcTime + self.rebalancingPeriod

        #algorithm.Debug("rebalance finished at " + str(algorithm.UtcTime))

        self.var.rebalance = False

        

        return targets

        

    def OnSecuritiesChanged(self, algorithm, changes):

        

        self.addedSymbols = [x.Symbol for x in changes.AddedSecurities]

        

        # Get removed symbol and invalidate them in the insight collection

        self.removedSymbols = [x.Symbol for x in changes.RemovedSecurities]

        self.insightCollection.Clear(self.removedSymbols)