Managing multiple independent Alpha Models

To manage orders from multiple independent alpha models, you can use the CompositeAlphaModel. This model combines multiple alpha models into a single alpha model and properly sets each insight's 'SourceModel' property. This allows you to track which alpha model generated the insight.

Here is an example of how you can use it:

from QuantConnect.Algorithm.Framework.Alphas import *
# ...
self.AddAlpha(AlphaModel1())
self.AddAlpha(AlphaModel2())
# ...

You can also use the InsightCollection and PortfolioTargetCollection helper classes to manage collections of Insight and PortfolioTarget respectively. These collections can be used in every Portfolio Construction Model and Execution Model.

Here is an example of how you can use these collections:

self.targetsCollection = PortfolioTargetCollection()
self.insightCollection = InsightCollection()
# ...
spy_insights = self.insightCollection['SPY'] # list of SPY insights 
spy_targets = self.portfolioTargetCollection['SPY'] # list of SPY portfolio targets

You can also implement a custom Portfolio Construction Model (PCM) that consumes multiple alphas. In this model, you can implement an InsightCollection and decide what to do with the active insights based on the source of the insight.

Here is an example of how you can use the GetActiveInsights method in your PCM:

# Get insight that haven't expired of each symbol that is still in the universe 
activeInsights = self.insightCollection.GetActiveInsights(algorithm.UtcTime)

For more information, you can refer to the following sources:

• Python Composite Alpha Model
• Framework Algorithm with Two or More Alphas
• Key Concepts
• Hybrid Algorithms

Source model is really okay, I can return insight with the source model simply by writing “insight.SourceModel = ”Model name" inside alpha model and then I can access it easily in portfolio model.The problem I have is accessing the quantity of a position, that a given alpha model has opened.Example: 

On one signal Model A bought 5 SPY's; Model B bought 7 SPY's. On another signal Model A bought 4 SPY's; Model B bought 9 SPY's. Rule is- each alpha can have a max of 15 SPY's and I need to enforce that, I suppose, in portfolio construction model. Is there a way to access the current position that a given alpha currently has?

I think I could do some counter inside the alpha model itself, on self. Wonder if there is a fancier way of doing so

To enforce a maximum quantity of a specific security for each alpha model, you could create a custom Portfolio Construction Model (PCM). In this PCM, you could keep track of the quantity of each security that each alpha model has opened.

Here's a rough idea of how you could implement this:

class CustomPCM(PortfolioConstructionModel):
    def __init__(self):
        self.alpha_positions = {}

    def CreateTargets(self, algorithm, insights):
        targets = []

        for insight in insights:
            # Get the current quantity of the security for the alpha model
            current_quantity = self.alpha_positions.get(insight.SourceModel, {}).get(insight.Symbol, 0)

            # Check if the alpha model has reached the maximum quantity for the security
            if abs(current_quantity + insight.Magnitude) > 15:
                continue

            # Update the quantity of the security for the alpha model
            self.alpha_positions.setdefault(insight.SourceModel, {})[insight.Symbol] = current_quantity + insight.Magnitude

            # Create a target for the insight
            targets.append(PortfolioTarget(insight.Symbol, insight.Magnitude))

        return targets

In this example, self.alpha_positions is a dictionary that keeps track of the quantity of each security that each alpha model has opened. The CreateTargets method checks if the alpha model has reached the maximum quantity for the security before creating a target for the insight.

Please note that this is a simplified example and you might need to adjust it according to your specific needs. For example, you might need to handle the case where an insight has a flat direction, which means that the alpha model wants to close the position for the security.

For more information, you can refer to the following sources:

• Python Composite Alpha Model
• Framework Algorithm with Two or More Alphas
• Key Concepts
• Hybrid Algorithms

Mia, could you give please an example of a more complex portfolio construction model which can handle flat positions too? Additionally, there should not be anything with magnitude.

The portfolio model should accept SourceModel; quantity; security

Then it should keep track of the quantity each model has for each security

Thank you

Based on the information provided, you can create a custom Portfolio Construction Model (PCM) that keeps track of the quantity of each security that each alpha model has opened. Here's a Python example of how you could implement this:

class CustomPCM(PortfolioConstructionModel):
    def __init__(self):
        self.alpha_positions = {}

    def CreateTargets(self, algorithm, insights):
        targets = []

        for insight in insights:
            # Get the current quantity of the security for the alpha model
            current_quantity = self.alpha_positions.get(insight.SourceModel, {}).get(insight.Symbol, 0)

            # Check if the alpha model has reached the maximum quantity for the security
            if abs(current_quantity + insight.Magnitude) > 15:
                continue

            # Update the quantity of the security for the alpha model
            self.alpha_positions.setdefault(insight.SourceModel, {})[insight.Symbol] = current_quantity + insight.Magnitude

            # Create a target for the insight
            targets.append(PortfolioTarget(insight.Symbol, insight.Magnitude))

        return targets

In this example, self.alpha_positions is a dictionary that keeps track of the quantity of each security that each alpha model has opened. The CreateTargets method checks if the alpha model has reached the maximum quantity for the security before creating a target for the insight.

Please note that this is a simplified example and you might need to adjust it according to your specific needs. For example, you might need to handle the case where an insight has a flat direction, which means that the alpha model wants to close the position for the security.

For more information, you can refer to the following sources:

• Python Composite Alpha Model
• Framework Algorithm with Two or More Alphas
• Key Concepts
• Hybrid Algorithms

Vytautas Zukauskas Alphas emit signals, not classical positions. If you're interested in a track record of alpha signals, it would be the alpha's responsibility to record it. 

I'd be wary of using alpha insights as a proxy for positions or trying to manage positions with them. It is the PCM and Execution model's responsibility to handle that work. 

You may find it easier to use the classic design of QCAlgorithm as it gives you a lot more control.