[Python] How to get portfolio and stock data into classes that are in other files?

Hmm the formatting on the code is hard to read, let me try again:

I'd try to cut the framework out.
Since you are running multiple algorithms over the same account, try implementing each algorithm as it's own, independent QCAlgorithm class.
Take the securities you want to trade as inputs to a constructor or otherwise make them settable from the outside.

Then you can do a main QCAlgorithm class that delegates to the others.

Also note that onData is merely the most talked about why to trigger trade decisions in QC land, schedule functions still work about the same as in Quantopian and you can even get your "data" object back by caching it in an instance variable.

Wow Thanks, you really got me thinking and after about 2 hours of failing I think I figured out a workable solution. I wasn't able to figure out what you meant by making multiple independent QCAlgorithm classes but I did figure out how to pass the OCAlgorithm parts that I need (data etc.) back and forth between the two files.

You can see what I did in the attached backtest. If you can describe in more detail the way to implement what you suggested I'd be open to that as well.

Lukel, like you I am converting a multi-strategy algo (800+ code lines) with sub-strategies trading groups of ETFs from Quantopian. Your post was a breakthrough for me. If I understand your QC solution, each sub-strategy gets its own file.py and the master algo calls each sub from main.py? Would you share more on your latest progress coding a multi-strat? What were the major stumbling blocks as you got further along and how did you resolve?

Everyone else, I am looking for more examples in Python so I understand QC structure and syntax correct.  If you have resources beyond the posted github examples, please point me in the right direction! Trying to reach the promised land by Sep 29, which is approaching all too quickly.

I have learned a lot since the post above, and achieved success in coding a multi-strategy algorithm. 

I left out a lot of the ordering stuff, and classes that the algorithms inherit from but that's all pretty unnessesary. here is just the bare bones:

Lukel, Great work! I will look into your multi-algo structure. Thanks :)

Brett,

I won't pretend to know the intricacies of how the data is pulled from QC but i think you have a slight misunderstanding. The indicators for each strategy are within each strategies .py file, in the compute_allocation functions. The indicators only use the self.stocks of that strategy. In return it fills up a dictionary (allocation) that the main.py or another file with execution logic can call individually and merge with all the other allocations.

Main.py only has the complete list so that it can call the data and have a record of which stocks belong to the strategies so that they can be used for execution in conjunction with the allocation.

I am probably not explaining it well but for example: algorithm1.py uses its self.stocks, SPY and TLT, with a SMA cross and creates an allocation. Algorithm2.py uses its self.stocks, SPY and GLD, with an EMA cross and generates an allocation. Each indicator only sees 2 stocks. Main.py iterates through the allocations to generate a combined allocation, probably combined_allocation[stock]+=algo.allocation[stock]*1.0/n where n is the number of algorithms. Then it uses the unique combined securities list (spy,tlt,gld)  to place orders based on the combined allocation without having any repeats (which would be problematic).

You really don't need to use the combined list a while lot. I use it for execution and checking to make sure the stocks in my universe thats also in the algorithm aren't part of the other strategies before purchase.

Sorry for typos I'm on mobile right now

I got the basic implementation done, now I'm double checking to make sure every function behaves in exactly the same way as I expect. I'm finding that there's a big difference between successfully executing code and getting the same behavior out of a signals and execution on both platforms.

The only thing I'm worried about is the memory limit, I can run a backtest for about 3 months before hitting it, I just don't know what/how to optimize if I hit it on live trading.

I think I will be ready to begin paper trading by the time Quantopian ends their live trading on the 29th

Luke,

You give me hope! Just curious, are you running on 1 account only ? I am RIA but trying to run 10-15 instances of same algo (with slightly different var settings on each to reflect risk tolerances). Still hoping to know what that will cost me from QC but no response yet.

LukeI, Well done! After testing your paper (or live) trading with QC, can you let us know how it went compared to Quantopian? Thanks :) 

Luke,

This approach works great when running the python files on the quantconnect site. Thanks for showing this solution. However when I try to run the same code on a local installation of LEAN I get an error indicating that Resolution is not defined. Here is the relevant error message:

Any ideas why LEAN is acting differently locally compared to the QC web site?

@Lukel Brett C. Any updates regarding treating algorithms as individual classes. I see a lot of people, especially new, having issues with the framework and want the explicit controls the classic algorithm offers. Any insights beyond what has already been shared would be appreciated.

Hi Samuel,

You may follow the solution from Lukel, or using multiple alpha models to merge insights. For example:

class yourAlgo(QCAlgorithm):
    def initialize(self):
        self.AddAlpha( AlphaModel1() )
        self.AddAlpha( AlphaModel2() )

class AlphaModel1( AlphaModel ):
    def __init__(self):
        pass    
    def Update(self, algorithm, data):
        insights = []
        # action on appending insights for alpha model 1
        return insights    
    def OnSecuritiesChanged(self, changes):
        pass
        
class AlphaModel2( AlphaModel ):
    def __init__(self):
        pass    
    def Update(self, algorithm, data):
        insights = []
        # action on appending insights for alpha model 2
        return insights    
    def OnSecuritiesChanged(self, changes):
        pass

We've attached a backtest example for your reference on using multiple alpha models to generate signals. 

Best,
Louis Szeto

Louis Szeto I understand with the framework you can add Alpha models and consolidate the insights. These then go to your portfolio constructor.

With that said, I would think (and please correct if I am wrong) it's much harder to track the insights from each alpha and do custom allocations in your portfolio constructor. Ex: if Alpha 1 has 30% of your portfolio and Alpha 2 has 70%, and both create an insight on Security X, one (Alpha 1) being buy and the other (Alpha 2) sell, these would create a neutral signal (since each insight is either up, flat or down) when really it should be a net short. If you use separate classes you can have each strategy return a number of shares/options and then place the net position.

I don't know if this is a situation where weighted insights may help, you calculate the weight for this trade idea as a percentage of the portfolio value and then write the portfolio constructor to add the weights and place that amount of shares based on the last share price? Ex: if Alpha 1 says buy 1200 shares of Security X at $42.00 and your portfolio is 1M, the weighting would be (.3)*(1200*42)/1M = .01512 for that insight and then the portfolio constructor calculates (.01512)*(1M)/(42.00) = 360 shares

Hi Samuel,

The insights will not be washed out by that, only the orders will by portfolio construction model. From the attached backtest, you will be able to see the insights are emitted individually.

It is possible to track each individual insight. Please check point no.2 from this docs. When the backtest is finished, you can go to the "insight" tab of results and download the .json file. The "source-model" attribute indicted which alpha model is this insight came from.

If you would like to adjust the weight according to different alpha models, you can access it by insight.SourceModel to get its alpha model's name(string). Please check the attached backtest for implementation example. Note this method will only change the ordering size but not the original insight weight.

Best,
Louis Szeto