Help with Portfolio Construction Model - Issue with PortfolioTarget.Percent() and Execution Prices

Hello Eugene,

Your concerns are valid and it's great that you're thinking about these aspects while designing your algorithm. Let's address your questions one by one:

1. The PortfolioTarget.Percent() function indeed calculates the target quantity based on the current price of the security. This is done to ensure that the target quantity is an integer, as you cannot hold fractional shares of a stock. However, you're correct that this can lead to discrepancies due to price movements between the time of target setting and order execution. One way to handle this could be to use a limit order in your Execution Model, which would ensure that your orders are executed at a price that is close to the price at the time of target setting. However, this approach has its own trade-offs, as limit orders may not get filled if the price moves away from the limit price.

2. Modifying the Execution Model to dynamically adjust quantities at the time of order execution could indeed be a solution. However, as you mentioned, this would add complexity to your algorithm. Another approach could be to use the OnOrderEvent() method to monitor the status of your orders and adjust your targets accordingly based on the actual fill prices. This would allow you to maintain the separation of concerns between the Portfolio Construction Model and the Execution Model.

3. Maintaining the integrity of percentage-based portfolio targets through market fluctuations is indeed a challenge. One approach could be to rebalance your portfolio more frequently to ensure that your portfolio stays close to your target allocations. However, this could increase transaction costs. Another approach could be to use a more sophisticated risk management model that takes into account market volatility and adjusts your portfolio targets accordingly.

Here's an example of how you can create a PortfolioTarget based on a portfolio weight:

# Calculate target equivalent to 10% of portfolio value
target = PortfolioTarget.Percent(algorithm, "IBM", 0.1)

And here's how you can access the PortfolioTarget objects for a Symbol:

portfolio_target = self.targets_collection[symbol]

I hope this helps! Let me know if you have any other questions.

Sources:

• Key Concepts - Portfolio Construction
• Clarification on Portfolio Construction targets for rebalancing
• How does SetHoldings work

Below is a custom FixedPercentagePortfolioConstructionModel that implements this solution:

import math
class FixedPercentagePortfolioConstructionModel(PortfolioConstructionModel):
    def __init__(self, allocation=0.05):
        super().__init__()
        self.allocation = allocation  # Allocation per position as a fraction of portfolio value
        self.insightCollection = InsightCollection()

    def Update(self, algorithm, insights):
        # Add new insights to the collection
        self.insightCollection.AddRange(insights)

    def OnSecuritiesChanged(self, algorithm, changes):
        # Remove insights for securities that are no longer in the universe
        for removed in changes.RemovedSecurities:
            self.insightCollection.Clear(removed.Symbol)

    def CreateTargets(self, algorithm, insights):
        # Update active insights
        self.Update(algorithm, insights)

        targets = []

        # Get active insights
        activeInsights = self.insightCollection.GetActiveInsights(algorithm.UtcTime)

        # Calculate total portfolio value
        portfolio_value = algorithm.Portfolio.TotalPortfolioValue

        for insight in activeInsights:
            symbol = insight.Symbol
            security = algorithm.Securities[symbol]

            # Calculate desired dollar allocation
            dollar_allocation = self.allocation * portfolio_value

            # Ensure the security is tradable
            if not security.IsTradable:
                algorithm.Debug(f"{symbol} is not tradable.")
                continue

            # Get current price
            price = security.Price

            if price == 0:
                algorithm.Debug(f"Price for {symbol} is zero.")
                continue

            # Calculate quantity to buy/sell
            quantity = dollar_allocation / price

            # Round quantity to the nearest lot size
            lot_size = security.SymbolProperties.LotSize
            quantity = math.floor(quantity / lot_size) * lot_size

            # Ensure quantity is non-zero
            if quantity == 0:
                algorithm.Debug(f"Calculated quantity for {symbol} is zero.")
                continue

            # Set direction
            if insight.Direction == InsightDirection.Up:
                pass  # Quantity remains positive
            elif insight.Direction == InsightDirection.Down:
                quantity = -quantity
            else:
                continue  # Skip if direction is flat

            targets.append(PortfolioTarget(symbol, quantity))
            algorithm.Debug(f"Creating target for {symbol}: Quantity {quantity}, Price {price}, Allocation ${dollar_allocation:.2f}")

        # Remove expired insights
        self.insightCollection.RemoveExpiredInsights(algorithm.UtcTime)
        return targets

In QCAlgorithm class:

# In your QCAlgorithm Initialize method
self.SetPortfolioConstruction(FixedPercentagePortfolioConstructionModel(allocation=0.05))