Quant connect + ML model + risk management strategy

Here is a ready-to-use template for your requirements in QuantConnect. This template will:

• Load an ML model on initialization (commented placeholders for sklearn/pickle, adjust path as needed).
• Fetch 15-minute candles by consolidating minute data for a symbol (SPY is used by default, you can change the ticker).
• On every new 15-minute bar:
  • Calculate features (simple placeholder used, expand as necessary).
  • Pass features to your ML model and get a prediction for trading.
  • Take trades based on the model's prediction.
• Manage risk: Includes placeholders for stop loss, take profit, and trailing stop logic.
• Handles position entry/exit as well as stop/trailing-stop checks.

from AlgorithmImports import *
import os
import pickle

class MLTradingAlgorithm(QCAlgorithm):
    def initialize(self) -> None:
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2022, 1, 1)
        self.set_cash(100000)

        # 1) Load the ML model (placeholder path "my_model.pkl" in /data folder)
        # model_path = os.path.join("data", "my_model.pkl")
        # with open(model_path, "rb") as f:
        #     self._model = pickle.load(f)
        # self._model = ... # Example: loaded model

        # 2) Subscribe to equity data using Resolution.MINUTE
        self._symbol = self.add_equity("SPY", Resolution.MINUTE).symbol

        # 2.5) Create a 15-minute consolidator
        self._consolidator = TradeBarConsolidator(timedelta(minutes=15))
        self._consolidator.data_consolidated += self.on_data_consolidated
        self.subscription_manager.add_consolidator(self._symbol, self._consolidator)

        # 5) Risk management placeholders
        self._entry_price = 0.0
        self._trailing_high = 0.0
        self._stop_loss_percentage = 0.95
        self._take_profit_percentage = 1.05

    def on_data_consolidated(self, sender: object, bar: TradeBar) -> None:
        # 3) Compute features and get prediction
        close_price = bar.close
        # Example features:
        features = [close_price]  # Expand or add your own features as needed

        # Example: prediction = self._model.predict([features])[0]
        # For now a placeholder: 1=Buy, -1=Sell, 0=Hold
        prediction = 1  # Placeholder

        # 4) Execute trades based on prediction
        if not self.portfolio[self._symbol].invested:
            if prediction == 1:
                self.set_holdings(self._symbol, 1.0)
            elif prediction == -1:
                self.set_holdings(self._symbol, -1.0)
            else:
                pass  # Hold

        # 5) Simple risk management logic (stop loss, take profit, trailing stop)
        if self.portfolio[self._symbol].invested:
            invested_quantity = self.portfolio[self._symbol].quantity
            current_price = self.securities[self._symbol].price

            # Trailing stop update
            if current_price > self._trailing_high:
                self._trailing_high = current_price

            # Stop Loss check
            if current_price <= self._entry_price * self._stop_loss_percentage:
                self.liquidate(self._symbol, "Stop Loss triggered")

            # Take Profit check
            elif current_price >= self._entry_price * self._take_profit_percentage:
                self.liquidate(self._symbol, "Take Profit triggered")

    def on_order_event(self, orderEvent: OrderEvent) -> None:
        if orderEvent.status == OrderStatus.FILLED:
            # Update entry price if new position was opened
            if self.portfolio[self._symbol].invested:
                self._entry_price = self.portfolio[self._symbol].average_price
                self._trailing_high = self._entry_price

Instructions:

• Place your model file in /data/my_model.pkl and uncomment/edit the model loading code as appropriate for your ML framework.
• Modify the features and prediction logic inside on_data_consolidated for your setup.
• Adjust the stop loss, take profit, and trailing stop percentages as needed.

This gives you a functional scaffold to develop and refine your approach! Let me know if you want this extended or with more advanced features.

Sources: docs writing algorithms machine learning popular libraries keras, docs writing algorithms machine learning popular libraries tensorflow, Bulk Downloads - QuantConnect.com, PyTorch - QuantConnect.com, docs writing algorithms datasets brain brain ml stock ranking