Lean: Cỗ Máy Giao dịch Thuật toán Mã nguồn Mở đằng sau QuantConnect — Hướng dẫn C# & Python 2026

class MyAlgorithm(QCAlgorithm):
    def Initialize(self):
        self.SetStartDate(2020, 1, 1)
        self.SetEndDate(2026, 1, 1)
        self.SetCash(100000)
        self.AddEquity("AAPL", Resolution.Daily)

// Cấu trúc thuật toán C#
namespace QuantConnect.Algorithm.CSharp
{
    public class MyAlgorithm : QCAlgorithm
    {
        public override void Initialize()
        {
            SetStartDate(2020, 1, 1);
            SetEndDate(2026, 1, 1);
            SetCash(100000);
            AddEquity("SPY", Resolution.Daily);
        }

        public override void OnData(Slice data)
        {
            if (!Portfolio.Invested)
            {
                SetHoldings("SPY", 1.0);
            }
        }
    }
}

# Ubuntu/Debian
sudo apt-get update && sudo apt-get install -y dotnet-sdk-8.0 git

# macOS
brew install dotnet-sdk git

# Windows — tải từ https://dotnet.microsoft.com/download

# Clone repository
git clone https://github.com/QuantConnect/Lean.git
cd Lean

# Build engine
dotnet build QuantConnect.Lean.sln

# Chạy backtest mẫu
dotnet run --project Launcher --config Config.json

# Cài Python.NET (bắt buộc cho thuật toán Python)
pip install pythonnet

# Cài wrapper API Python của Lean
pip install quantconnect-stubs

# Xác minh cài đặt
python -c "from Algorithm.Python import *; print('Lean Python ready')"

# Pull image chính thức
docker pull quantconnect/lean:latest

# Chạy backtest trong container
docker run -v "$(pwd)/Data:/Data" \
  -v "$(pwd)/Results:/Results" \
  quantconnect/lean:latest --backtest

from AlgorithmImports import *

class SmaCrossoverAlgorithm(QCAlgorithm):
    def Initialize(self):
        # Chu kỳ backtest
        self.SetStartDate(2020, 1, 1)
        self.SetEndDate(2026, 1, 1)
        self.SetCash(100000)
        
        # Thêm cổ phiếu
        self.symbol = self.AddEquity("AAPL", Resolution.Daily).Symbol
        
        # Tạo chỉ báo SMA
        self.fast_sma = self.SMA(self.symbol, 20, Resolution.Daily)
        self.slow_sma = self.SMA(self.symbol, 50, Resolution.Daily)
        
        # Warm up chỉ báo trước khi giao dịch
        self.SetWarmUp(50)
        
        # Theo dõi trạng thái trước đó để phát hiện crossover
        self.previous_fast = None
        self.previous_slow = None

    def OnData(self, data: Slice):
        if self.IsWarmingUp:
            return
        
        # Lấy giá trị SMA hiện tại
        fast_val = self.fast_sma.Current.Value
        slow_val = self.slow_sma.Current.Value
        
        # Kiểm tra crossover trên dữ liệu hợp lệ đầu tiên
        if self.previous_fast is not None:
            # Golden cross: fast cắt lên trên slow
            if self.previous_fast <= self.previous_slow and fast_val > slow_val:
                if not self.Portfolio[self.symbol].Invested:
                    self.SetHoldings(self.symbol, 1.0)
            
            # Death cross: fast cắt xuống dưới slow
            elif self.previous_fast >= self.previous_slow and fast_val < slow_val:
                if self.Portfolio[self.symbol].Invested:
                    self.Liquidate(self.symbol)
        
        self.previous_fast = fast_val
        self.previous_slow = slow_val

# Lưu thành main.py, sau đó:
lean backtest "MyProject" --output results.json

from AlgorithmImports import *
import numpy as np

class RiskParityAlgorithm(QCAlgorithm):
    def Initialize(self):
        self.SetStartDate(2020, 1, 1)
        self.SetEndDate(2026, 1, 1)
        self.SetCash(100000)
        
        # Định nghĩa universe
        self.symbols = [
            self.AddEquity("SPY", Resolution.Daily).Symbol,   # S&P 500
            self.AddEquity("TLT", Resolution.Daily).Symbol,   # Trái phiếu Kỳ hạn 20 năm
            self.AddEquity("GLD", Resolution.Daily).Symbol,   # Vàng
            self.AddEquity("VIXY", Resolution.Daily).Symbol,  # VIX
        ]
        
        # Cửa sổ rolling tính độ biến động
        self.lookback = 60
        self.rebalance_interval = 30  # Ngày
        self.days_since_rebalance = 0

    def OnData(self, data: Slice):
        self.days_since_rebalance += 1
        
        if self.days_since_rebalance < self.rebalance_interval:
            return
        
        self.days_since_rebalance = 0
        
        # Tính trọng số nghịch đảo độ biến động
        volatilities = {}
        for symbol in self.symbols:
            history = self.History(symbol, self.lookback, Resolution.Daily)
            if len(history) < self.lookback:
                return
            returns = history["close"].pct_change().dropna()
            volatilities[symbol] = returns.std()
        
        # Trọng số nghịch đảo độ biến động
        inv_vol = {s: 1.0 / v for s, v in volatilities.items()}
        total = sum(inv_vol.values())
        weights = {s: v / total for s, v in inv_vol.items()}
        
        # Cân bằng lại
        for symbol, weight in weights.items():
            self.SetHoldings(symbol, weight)
        
        self.Debug(f"Rebalanced: {weights}")

from AlgorithmImports import *

class OptionsStraddleAlgorithm(QCAlgorithm):
    def Initialize(self):
        self.SetStartDate(2023, 1, 1)
        self.SetEndDate(2026, 1, 1)
        self.SetCash(50000)
        
        # Thêm cổ phiếu và chuỗi quyền chọn
        equity = self.AddEquity("SPY", Resolution.Minute)
        option = self.AddOption("SPY")
        option.SetFilter(-2, 2, timedelta(7), timedelta(30))
        self.symbol = option.Symbol
        
        self.Schedule.On(
            self.DateRules.WeekStart("SPY"),
            self.TimeRules.AfterMarketOpen("SPY", 30),
            self.TradeStraddle
        )

    def TradeStraddle(self):
        if self.Portfolio.Invested:
            return
        
        chain = self.CurrentSlice.OptionChains.get(self.symbol)
        if chain is None:
            return
        
        # Tìm quyền chọn ATM
        atm_strike = sorted(chain,
            key=lambda x: abs(x.Strike - chain.Underlying.Price))[0]
        
        atm_call = [x for x in chain if x.Strike == atm_strike.Strike and x.Right == OptionRight.Call][0]
        atm_put = [x for x in chain if x.Strike == atm_strike.Strike and x.Right == OptionRight.Put][0]
        
        # Mua straddle
        self.Buy(atm_call.Symbol, 1)
        self.Buy(atm_put.Symbol, 1)

from AlgorithmImports import *

class LiveSmaAlgorithm(QCAlgorithm):
    def Initialize(self):
        self.SetStartDate(2026, 1, 1)
        self.SetCash(10000)
        
        # Dữ liệu thực từ Interactive Brokers
        self.SetBrokerageModel(BrokerageName.InteractiveBrokersBrokerage)
        self.AddEquity("AAPL", Resolution.Minute)
        
        # Hoặc paper trading với QuantConnect
        # self.SetBrokerageModel(BrokerageName.QuantConnectBrokerage)

    def OnData(self, data):
        # Cùng logic như backtest
        pass

{
  "environment": "live",
  "algorithm-type-name": "LiveSmaAlgorithm",
  "algorithm-language": "Python",
  "algorithm-location": "./MyAlgorithm.py",
  "job-user-id": "YOUR_USER_ID",
  "api-access-token": "YOUR_TOKEN",
  "ib-account": "DU123456",
  "ib-host": "127.0.0.1",
  "ib-port": 7497
}

from AlgorithmImports import *
import pickle
import numpy as np

class MLPredictionAlgorithm(QCAlgorithm):
    def Initialize(self):
        self.SetStartDate(2023, 1, 1)
        self.SetEndDate(2026, 1, 1)
        self.SetCash(50000)
        
        self.symbol = self.AddEquity("SPY", Resolution.Daily).Symbol
        
        # Load model đã train trước
        model_path = "./models/spy_predictor.pkl"
        with open(model_path, 'rb') as f:
            self.model = pickle.load(f)
        
        # Lịch sử giá làm feature
        self.price_history = RollingWindow[float](20)

    def OnData(self, data: Slice):
        if not data.ContainsKey(self.symbol):
            return
        
        price = data[self.symbol].Close
        self.price_history.Add(float(price))
        
        if not self.price_history.IsReady:
            return
        
        # Tạo feature từ lịch sử giá
        features = np.array(list(self.price_history)).reshape(1, -1)
        prediction = self.model.predict(features)[0]
        
        # 1 = dự đoán tăng, 0 = dự đoán giảm
        if prediction == 1 and not self.Portfolio[self.symbol].Invested:
            self.SetHoldings(self.symbol, 1.0)
        elif prediction == 0 and self.Portfolio[self.symbol].Invested:
            self.Liquidate(self.symbol)

from AlgorithmImports import *

class CustomAlphaModel(AlphaModel):
    def __init__(self):
        self.name = "CustomAlpha"
        self.securities = []
    
    def Update(self, algorithm: QCAlgorithm, data: Slice) -> List[Insight]:
        insights = []
        
        for security in self.securities:
            symbol = security.Symbol
            history = algorithm.History(symbol, 30, Resolution.Daily)
            
            if len(history) < 30:
                continue
            
            # Tín hiệu mean reversion
            sma = history["close"].mean()
            price = algorithm.Securities[symbol].Price
            
            if price < sma * 0.95:  # 5% dưới SMA = tín hiệu mua
                insights.append(Insight.Price(
                    symbol, timedelta(5), InsightDirection.Up
                ))
            elif price > sma * 1.05:  # 5% trên SMA = tín hiệu bán
                insights.append(Insight.Price(
                    symbol, timedelta(5), InsightDirection.Down
                ))
        
        return insights
    
    def OnSecuritiesChanged(self, algorithm, changes):
        self.securities.extend(changes.AddedSecurities)
        for removed in changes.RemovedSecurities:
            self.securities.remove(removed)

from AlgorithmImports import *

class MaxDrawdownRiskManagement(RiskManagementModel):
    def __init__(self, max_drawdown=0.10):
        self.max_drawdown = max_drawdown
        self.peak_value = 0
    
    def ManageRisk(self, algorithm: QCAlgorithm, targets: List[PortfolioTarget]):
        current_value = algorithm.Portfolio.TotalPortfolioValue
        
        if current_value > self.peak_value:
            self.peak_value = current_value
        
        drawdown = (self.peak_value - current_value) / self.peak_value
        
        if drawdown > self.max_drawdown:
            algorithm.Error(f"Max drawdown hit: {drawdown:.2%}. Liquidating.")
            algorithm.Liquidate()
            return []
        
        return targets

from AlgorithmImports import *

class FundamentalUniverseAlgorithm(QCAlgorithm):
    def Initialize(self):
        self.SetStartDate(2022, 1, 1)
        self.SetEndDate(2026, 1, 1)
        self.SetCash(100000)
        
        # Chọn top 50 cổ phiếu theo vốn hóa
        self.AddUniverse(
            self.CoarseSelectionFilter,
            self.FineSelectionFilter
        )
        self.UniverseSettings.Resolution = Resolution.Daily
    
    def CoarseSelectionFilter(self, coarse):
        # Lọc cổ phiếu thanh khoản
        sorted_by_dollar_volume = sorted(
            coarse, 
            key=lambda x: x.DollarVolume, 
            reverse=True
        )
        return [x.Symbol for x in sorted_by_dollar_volume[:100]]
    
    def FineSelectionFilter(self, fine):
        # Chọn theo fundamentals
        sorted_by_market_cap = sorted(
            fine,
            key=lambda x: x.MarketCap,
            reverse=True
        )
        return [x.Symbol for x in sorted_by_market_cap[:50]]

    def OnData(self, data):
        # Rebalance hàng tháng
        pass