Millennium Management 独立团队制策略

import numpy as np
import pandas as pd
import yfinance as yf
from datetime import datetime, timedelta
from scipy.optimize import minimize
import warnings
warnings.filterwarnings('ignore')

class MillenniumPodSystem:
    """
    Millennium Management-inspired multi-strategy pod system for retail investors.

    Manages 3-5 independent trading strategies with:
    - Automated stop-loss rules (5% → 50% cut, 10% → termination)
    - Dynamic capital allocation based on Sharpe ratios
    - Monthly rebalancing with position limits
    - Daily risk monitoring and drawdown tracking
    """

    def __init__(self, initial_capital=100000, num_pods=5):
        """
        Initialize pod system.

        Parameters:
        -----------
        initial_capital : float
            Starting portfolio capital (default: $100k)
        num_pods : int
            Number of independent strategies (default: 5)
        """
        self.initial_capital = initial_capital
        self.num_pods = num_pods
        self.current_capital = initial_capital
        self.cash_reserve_pct = 0.10  # 10% cash buffer

        # Pod state tracking
        self.pod_names = [f'Pod_{i+1}' for i in range(num_pods)]
        self.pod_allocations = {}  # Current capital allocation per pod
        self.pod_peaks = {}  # High-water mark for each pod
        self.pod_returns_history = {pod: [] for pod in self.pod_names}
        self.pod_sharpe_ratios = {}
        self.pod_status = {pod: 'active' for pod in self.pod_names}

        # Risk limits (Millennium-style)
        self.stop_loss_levels = {
            'warning': 0.05,      # 5% DD → 50% capital reduction
            'termination': 0.10   # 10% DD → strategy terminated
        }

        # Allocation constraints
        self.min_allocation_pct = 0.10  # Min 10% per active pod
        self.max_allocation_pct = 0.40  # Max 40% per pod (avoid concentration)

        # Initialize equal-weight allocation
        self.initialize_pods()

        print(f"\n{'='*60}")
        print(f"MILLENNIUM POD SYSTEM INITIALIZED")
        print(f"{'='*60}")
        print(f"Initial Capital:     ${self.initial_capital:,.0f}")
        print(f"Number of Pods:      {self.num_pods}")
        print(f"Cash Reserve:        {self.cash_reserve_pct:.0%}")
        print(f"Stop-Loss (Warning): {self.stop_loss_levels['warning']:.0%}")
        print(f"Stop-Loss (Term):    {self.stop_loss_levels['termination']:.0%}")
        print(f"{'='*60}\n")

    def initialize_pods(self):
        """
        Initialize pods with equal-weight capital allocation.
        """
        # Reserve 10% cash, distribute rest equally
        investable_capital = self.initial_capital * (1 - self.cash_reserve_pct)
        equal_weight = investable_capital / self.num_pods

        for pod in self.pod_names:
            self.pod_allocations[pod] = equal_weight
            self.pod_peaks[pod] = equal_weight
            self.pod_sharpe_ratios[pod] = 1.0  # Assume 1.0 Sharpe initially

        print("Initial Pod Allocations (Equal Weight):")
        for pod, capital in self.pod_allocations.items():
            pct = (capital / self.initial_capital) * 100
            print(f"  {pod}: ${capital:,.0f} ({pct:.1f}%)")
        print(f"  Cash Reserve: ${self.initial_capital * self.cash_reserve_pct:,.0f} ({self.cash_reserve_pct:.0%})\n")

    def simulate_pod_returns(self, days=252):
        """
        Simulate daily returns for each pod (for demonstration).

        In production, replace this with actual strategy returns from your
        backtesting systems (e.g., equity L/S, stat arb, volatility, etc.)

        Parameters:
        -----------
        days : int
            Number of trading days to simulate

        Returns:
        --------
        pd.DataFrame
            Daily returns for each pod
        """
        np.random.seed(42)

        # Simulate different Sharpe ratios for each pod
        # Pod 1: High Sharpe (2.0) - Statistical Arbitrage
        # Pod 2: Medium-High (1.6) - Equity Long/Short
        # Pod 3: Medium (1.2) - Volatility Trading
        # Pod 4: Medium (1.4) - Alternative Data
        # Pod 5: Lower (0.9) - Momentum (will get reduced allocation)

        sharpe_targets = [2.0, 1.6, 1.2, 1.4, 0.9]
        volatilities = [0.10, 0.12, 0.15, 0.13, 0.18]  # Annual volatility

        returns_data = {}
        dates = pd.date_range(end=datetime.now(), periods=days, freq='D')

        for i, pod in enumerate(self.pod_names):
            # Target return from Sharpe: Return = RiskFree + Sharpe * Vol
            risk_free = 0.045  # 4.5% annual
            target_return = risk_free + sharpe_targets[i] * volatilities[i]

            # Daily parameters
            daily_return = target_return / 252
            daily_vol = volatilities[i] / np.sqrt(252)

            # Generate returns (with some autocorrelation for realism)
            returns = np.random.normal(daily_return, daily_vol, days)

            # Add momentum/mean-reversion (slight autocorrelation)
            for j in range(1, len(returns)):
                returns[j] += 0.1 * returns[j-1]  # Slight momentum

            returns_data[pod] = returns

        df = pd.DataFrame(returns_data, index=dates)
        return df

    def calculate_drawdown(self, capital_series):
        """
        Calculate drawdown from peak for a capital series.

        Parameters:
        -----------
        capital_series : pd.Series or np.array
            Time series of capital values

        Returns:
        --------
        float
            Current drawdown from peak (as decimal, e.g., 0.05 = 5%)
        """
        if isinstance(capital_series, pd.Series):
            capital_series = capital_series.values

        peak = np.maximum.accumulate(capital_series)
        drawdown = (capital_series - peak) / peak
        return drawdown[-1]

    def calculate_sharpe_ratio(self, returns, risk_free_rate=0.045):
        """
        Calculate annualized Sharpe ratio.

        Parameters:
        -----------
        returns : np.array or pd.Series
            Daily returns
        risk_free_rate : float
            Annual risk-free rate (default: 4.5%)

        Returns:
        --------
        float
            Annualized Sharpe ratio
        """
        if len(returns) < 30:
            return 0.0  # Insufficient data

        mean_return = np.mean(returns) * 252  # Annualize
        volatility = np.std(returns) * np.sqrt(252)  # Annualize

        if volatility == 0:
            return 0.0

        sharpe = (mean_return - risk_free_rate) / volatility
        return sharpe

    def check_stop_losses(self, returns_df):
        """
        Check if any pods have hit stop-loss levels.
        Apply capital reductions or terminations.

        Parameters:
        -----------
        returns_df : pd.DataFrame
            Daily returns for each pod
        """
        print(f"\n{'='*60}")
        print("CHECKING STOP-LOSS TRIGGERS")
        print(f"{'='*60}\n")

        for pod in self.pod_names:
            if self.pod_status[pod] != 'active':
                continue  # Skip terminated pods

            # Calculate pod's cumulative capital
            pod_returns = returns_df[pod]
            cumulative_capital = self.pod_peaks[pod] * (1 + pod_returns).cumprod()

            # Current drawdown
            current_dd = self.calculate_drawdown(cumulative_capital)

            print(f"{pod}:")
            print(f"  Peak Capital:      ${self.pod_peaks[pod]:,.0f}")
            print(f"  Current Capital:   ${cumulative_capital.iloc[-1]:,.0f}")
            print(f"  Drawdown:          {current_dd:.2%}")

            # Check termination level (10%)
            if current_dd <= -self.stop_loss_levels['termination']:
                print(f"  ⚠️  STOP-LOSS TRIGGERED: Terminating {pod}")
                self.pod_status[pod] = 'terminated'
                self.pod_allocations[pod] = 0.0
                print(f"  Status:            TERMINATED\n")
                continue

            # Check warning level (5%)
            elif current_dd <= -self.stop_loss_levels['warning']:
                # Cut allocation by 50%
                old_allocation = self.pod_allocations[pod]
                self.pod_allocations[pod] *= 0.5
                print(f"  ⚠️  WARNING: 5% DD → Cutting allocation by 50%")
                print(f"  Old Allocation:    ${old_allocation:,.0f}")
                print(f"  New Allocation:    ${self.pod_allocations[pod]:,.0f}\n")
            else:
                print(f"  Status:            OK\n")

    def calculate_sharpe_weighted_allocation(self):
        """
        Calculate Sharpe-weighted capital allocation across active pods.

        Returns:
        --------
        dict
            Target allocation for each pod
        """
        # Get Sharpe ratios for active pods
        active_pods = [pod for pod in self.pod_names if self.pod_status[pod] == 'active']

        if len(active_pods) == 0:
            print("⚠️  Warning: No active pods remaining!")
            return {pod: 0.0 for pod in self.pod_names}

        # Calculate raw Sharpe-weighted allocation
        sharpe_values = np.array([max(self.pod_sharpe_ratios[pod], 0) for pod in active_pods])

        if sharpe_values.sum() == 0:
            # All Sharpe ratios are negative → equal weight
            weights = np.ones(len(active_pods)) / len(active_pods)
        else:
            weights = sharpe_values / sharpe_values.sum()

        # Apply constraints (min 10%, max 40%)
        investable_capital = self.current_capital * (1 - self.cash_reserve_pct)

        allocations = {}
        for i, pod in enumerate(active_pods):
            raw_allocation = weights[i] * investable_capital

            # Apply min/max constraints
            allocation = np.clip(
                raw_allocation,
                self.min_allocation_pct * investable_capital,
                self.max_allocation_pct * investable_capital
            )
            allocations[pod] = allocation

        # Normalize to ensure sum = investable_capital
        total_allocated = sum(allocations.values())
        if total_allocated > 0:
            for pod in allocations:
                allocations[pod] = (allocations[pod] / total_allocated) * investable_capital

        # Set terminated pods to 0
        for pod in self.pod_names:
            if self.pod_status[pod] != 'active':
                allocations[pod] = 0.0

        return allocations

    def rebalance_portfolio(self, returns_df):
        """
        Monthly rebalancing: update Sharpe ratios and reallocate capital.

        Parameters:
        -----------
        returns_df : pd.DataFrame
            Historical daily returns for each pod (past 252 days)
        """
        print(f"\n{'='*60}")
        print("MONTHLY REBALANCING")
        print(f"{'='*60}\n")

        # Update Sharpe ratios (rolling 252-day)
        for pod in self.pod_names:
            if self.pod_status[pod] == 'active':
                pod_returns = returns_df[pod].iloc[-252:]  # Past year
                self.pod_sharpe_ratios[pod] = self.calculate_sharpe_ratio(pod_returns)

        # Display Sharpe ratios
        print("Updated Sharpe Ratios:")
        for pod in self.pod_names:
            status = self.pod_status[pod]
            sharpe = self.pod_sharpe_ratios.get(pod, 0)
            print(f"  {pod}: {sharpe:.2f} ({status})")

        # Calculate new Sharpe-weighted allocation
        new_allocations = self.calculate_sharpe_weighted_allocation()

        # Display rebalancing
        print(f"\nRebalancing Portfolio:")
        print(f"{'Pod':<10} {'Old Alloc':<15} {'New Alloc':<15} {'Change':<15}")
        print("-" * 60)

        for pod in self.pod_names:
            old_alloc = self.pod_allocations.get(pod, 0)
            new_alloc = new_allocations.get(pod, 0)
            change = new_alloc - old_alloc

            print(f"{pod:<10} ${old_alloc:>12,.0f}  ${new_alloc:>12,.0f}  ${change:>+12,.0f}")

        # Apply new allocations
        self.pod_allocations = new_allocations

        # Update peaks for active pods
        for pod in self.pod_names:
            if self.pod_status[pod] == 'active':
                self.pod_peaks[pod] = max(self.pod_peaks[pod], self.pod_allocations[pod])

        print(f"\nCash Reserve: ${self.current_capital * self.cash_reserve_pct:,.0f} ({self.cash_reserve_pct:.0%})")
        print(f"{'='*60}\n")

    def run_backtest(self, start_date='2015-01-01', end_date='2025-01-01'):
        """
        Backtest the pod system over historical period.

        Parameters:
        -----------
        start_date, end_date : str
            Backtest date range (YYYY-MM-DD)

        Returns:
        --------
        pd.DataFrame
            Daily portfolio returns and metrics
        """
        print(f"\n{'='*60}")
        print(f"RUNNING BACKTEST: {start_date} to {end_date}")
        print(f"{'='*60}\n")

        # Generate pod returns (in production, use actual strategy returns)
        trading_days = pd.bdate_range(start_date, end_date)
        returns_df = self.simulate_pod_returns(days=len(trading_days))
        returns_df.index = trading_days

        # Portfolio tracking
        portfolio_values = [self.initial_capital]
        portfolio_returns = []

        # Monthly rebalancing schedule (first trading day of each month)
        rebalance_dates = returns_df.resample('MS').first().index

        for date in returns_df.index[1:]:
            # Check if it's a rebalancing date
            if date in rebalance_dates:
                # Use past 252 days for Sharpe calculation
                lookback_returns = returns_df.loc[:date].iloc[-252:]
                self.rebalance_portfolio(lookback_returns)

            # Daily return calculation
            daily_pod_returns = returns_df.loc[date]

            # Portfolio return = weighted sum of pod returns
            portfolio_return = 0
            for pod in self.pod_names:
                if self.pod_status[pod] == 'active' and self.pod_allocations[pod] > 0:
                    weight = self.pod_allocations[pod] / self.current_capital
                    portfolio_return += weight * daily_pod_returns[pod]

            portfolio_returns.append(portfolio_return)

            # Update portfolio value
            new_value = portfolio_values[-1] * (1 + portfolio_return)
            portfolio_values.append(new_value)
            self.current_capital = new_value

            # Check stop-losses weekly (every Friday or last trading day of week)
            if date.weekday() == 4:  # Friday
                self.check_stop_losses(returns_df.loc[:date])

        # Create results DataFrame
        results = pd.DataFrame({
            'date': returns_df.index,
            'portfolio_value': portfolio_values[:-1],  # Align with dates
            'return': [0] + portfolio_returns
        })

        results['cumulative_return'] = (results['portfolio_value'] / self.initial_capital) - 1

        # Calculate performance metrics
        total_return = results['cumulative_return'].iloc[-1]
        n_years = len(results) / 252
        cagr = (1 + total_return) ** (1/n_years) - 1
        volatility = results['return'].std() * np.sqrt(252)
        sharpe = (results['return'].mean() * 252) / volatility
        max_dd = (results['cumulative_return'] - results['cumulative_return'].cummax()).min()

        # Calculate max monthly loss
        monthly_returns = results.set_index('date')['return'].resample('M').apply(lambda x: (1 + x).prod() - 1)
        max_monthly_loss = monthly_returns.min()

        print(f"\n{'='*60}")
        print("BACKTEST RESULTS")
        print(f"{'='*60}")
        print(f"Total Return:        {total_return:>10.1%}")
        print(f"CAGR:                {cagr:>10.1%}")
        print(f"Volatility (ann.):   {volatility:>10.1%}")
        print(f"Sharpe Ratio:        {sharpe:>10.2f}")
        print(f"Max Drawdown:        {max_dd:>10.1%}")
        print(f"Max Monthly Loss:    {max_monthly_loss:>10.1%}")
        print(f"Final Capital:       ${self.current_capital:>12,.0f}")
        print(f"{'='*60}\n")

        # Pod-level performance summary
        print("POD PERFORMANCE SUMMARY:")
        print(f"{'Pod':<10} {'Status':<12} {'Final Sharpe':<15} {'Final Allocation':<20}")
        print("-" * 60)
        for pod in self.pod_names:
            status = self.pod_status[pod]
            sharpe = self.pod_sharpe_ratios.get(pod, 0)
            allocation = self.pod_allocations.get(pod, 0)
            allocation_pct = (allocation / self.current_capital) * 100 if self.current_capital > 0 else 0

            print(f"{pod:<10} {status:<12} {sharpe:>12.2f}  ${allocation:>12,.0f} ({allocation_pct:>5.1f}%)")

        print(f"{'='*60}\n")

        return results


def main():
    """
    Run Millennium-style pod system backtest.
    """
    print("\n" + "="*60)
    print("MILLENNIUM POD STRUCTURE STRATEGY")
    print("Retail Multi-Strategy Implementation")
    print("="*60 + "\n")

    # Initialize pod system
    # In production, you would pass actual strategy objects/classes
    pod_system = MillenniumPodSystem(
        initial_capital=100000,  # $100k starting capital
        num_pods=5               # 5 independent strategies
    )

    # Run backtest
    results = pod_system.run_backtest(
        start_date='2015-01-01',
        end_date='2025-01-01'
    )

    # Additional analysis
    print("\nYEAR-BY-YEAR RETURNS:")
    print("-" * 40)
    results['year'] = pd.to_datetime(results['date']).dt.year
    yearly_returns = results.groupby('year')['return'].apply(lambda x: (1 + x).prod() - 1)

    for year, ret in yearly_returns.items():
        print(f"{year}: {ret:>8.2%}")

    print("\n" + "="*60)
    print("Backtest complete!")
    print("="*60 + "\n")


if __name__ == "__main__":
    main()