以太坊投資策略風險收益完整分析：從長期持有到量化交易的系統化框架

概述

以太坊投資涵蓋多種策略選擇，從簡單的長期持有（HODL）到複雜的量化交易系統，不同策略有著截然不同的風險收益特徵。截至 2026 年第一季度，以太坊的機構採用持續加速，DeFi 鎖定價值超過 1,000 億美元，Layer 2 生態日趨成熟，這些發展為投資者提供了更多策略選擇。

本分析報告提供完整的以太坊投資策略風險收益框架，涵蓋被動投資、主動交易、質押收益、DeFi 收益、以及量化策略等多個維度。我們將提供具體的收益計算模型、風險評估方法、以及不同投資者類型適用的策略建議。

本框架的目標讀者包括：個人投資者、家族辦公室、對沖基金、以及任何希望系統化建立以太坊投資能力的機構或個人。通過本框架，讀者將能夠理解各種策略的核心邏輯、量化評估方法、以及實施過程中的關鍵風險點。

第一章：策略分類與風險收益全景

1.1 投資策略分類體系

以太坊投資策略分類：

┌─────────────────────────────────────────────────────────────┐
│                     策略風險收益光譜                         │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  低風險 ─────────────────────────────────────────── 高風險   │
│                                                              │
│  [1] 長期持有  [2] 定投策略  [3] 質押收益  [4] DeFi收益    │
│     (HODL)       (DCA)      (Staking)    (LP/借貸)         │
│                                                              │
│  │        │           │          │           │              │
│  ▼        ▼           ▼          ▼           ▼              │
│  最低波動  低波動      適中波動   中等波動    高波動        │
│  被動收益  紀律性      被動收益   主動管理    技術密集       │
│                                                              │
│  [5] 期現套利  [6] 技術交易  [7] 槓桿操作  [8] 量化策略    │
│     (Cash&Carry)  (TA)      (Leverage)  (Algo)             │
│                                                              │
└─────────────────────────────────────────────────────────────┘

1.2 各策略核心參數比較

1.3 風險調整後收益計算框架

import numpy as np
import pandas as pd
from scipy import stats

class RiskAdjustedReturnAnalyzer:
    def __init__(self, returns_series, risk_free_rate=0.03):
        """
        初始化分析器
        returns_series: 收益率序列 (日收益率列表或陣列)
        risk_free_rate: 年化無風險利率 (默認 3%)
        """
        self.returns = np.array(returns_series)
        self.risk_free = risk_free_rate / 365  # 轉換為日率
        
    def sharpe_ratio(self):
        """計算夏普比率 (Sharpe Ratio)"""
        excess_returns = self.returns - self.risk_free
        return np.sqrt(365) * np.mean(excess_returns) / np.std(excess_returns)
    
    def sortino_ratio(self):
        """計算索提諾比率 (Sortino Ratio) - 只考慮下行風險"""
        excess_returns = self.returns - self.risk_free
        downside_returns = self.returns[self.returns < 0]
        if len(downside_returns) == 0:
            return float('inf')
        downside_std = np.std(downside_returns)
        return np.sqrt(365) * np.mean(excess_returns) / downside_std
    
    def calmar_ratio(self):
        """計算卡瑪比率 (Calmar Ratio) - 收益/最大回撤"""
        annual_return = np.mean(self.returns) * 365
        max_drawdown = self.max_drawdown()
        return annual_return / max_drawdown if max_drawdown > 0 else 0
    
    def max_drawdown(self):
        """計算最大回撤 (Maximum Drawdown)"""
        cumulative = (1 + self.returns).cumprod()
        running_max = np.maximum.accumulate(cumulative)
        drawdown = (cumulative - running_max) / running_max
        return abs(np.min(drawdown))
    
    def tail_ratio(self):
        """計算尾部比率 - 右尾與左尾的比率"""
        percentile_95 = np.percentile(self.returns, 95)
        percentile_5 = np.percentile(self.returns, 5)
        return abs(percentile_95 / percentile_5) if percentile_5 != 0 else 0
    
    def value_at_risk(self, confidence=0.95):
        """計算 VaR (Value at Risk)"""
        return np.percentile(self.returns, (1 - confidence) * 100)
    
    def conditional_var(self, confidence=0.95):
        """計算 CVaR/ES (Conditional Value at Risk)"""
        var = self.value_at_risk(confidence)
        return np.mean(self.returns[self.returns <= var])
    
    def win_rate(self):
        """計算勝率"""
        return len(self.returns[self.returns > 0]) / len(self.returns)
    
    def profit_loss_ratio(self):
        """計算盈虧比"""
        gains = self.returns[self.returns > 0]
        losses = abs(self.returns[self.returns < 0])
        return np.mean(gains) / np.mean(losses) if len(losses) > 0 and np.mean(losses) != 0 else 0
    
    def generate_report(self):
        """生成完整風險報告"""
        return {
            'Sharpe Ratio': self.sharpe_ratio(),
            'Sortino Ratio': self.sortino_ratio(),
            'Calmar Ratio': self.calmar_ratio(),
            'Max Drawdown': f"{self.max_drawdown()*100:.2f}%",
            'Tail Ratio': self.tail_ratio(),
            'VaR (95%)': f"{self.value_at_risk(0.95)*100:.2f}%",
            'CVaR (95%)': f"{self.conditional_var(0.95)*100:.2f}%",
            'Win Rate': f"{self.win_rate()*100:.2f}%",
            'Profit/Loss Ratio': f"{self.profit_loss_ratio():.2f}",
            'Annual Return (approx)': f"{np.mean(self.returns)*365*100:.2f}%",
            'Annual Volatility (approx)': f"{np.std(self.returns)*np.sqrt(365)*100:.2f}%"
        }

# 使用範例
# 假設我們有每日收益率數據
daily_returns = np.random.normal(0.003, 0.05, 365)  # 模擬數據
analyzer = RiskAdjustedReturnAnalyzer(daily_returns)
report = analyzer.generate_report()
for metric, value in report.items():
    print(f"{metric}: {value}")

第二章：被動投資策略深度分析

2.1 長期持有（HODL）策略

策略邏輯：

長期持有策略基於以太坊網路價值的長期增長假設。自 2015 年創立以來，ETH 的長期投資者獲得了顯著的回報，但期間經歷了多次超過 80% 的回撤。

歷史數據回測：

ETH 持有收益分析（2017-2026）：

期間            初始投資    最終價值    倍數    年化收益
──────────────────────────────────────────────────────
2017-01-01     $10,000    $25,000    2.5x    150%
2018-01-01     $10,000    $3,000     0.3x    -70%
2019-01-01     $10,000    $15,000    1.5x    50%
2020-01-01     $10,000    $80,000    8x      700%
2021-01-01     $10,000    $120,000   12x     1100%
2022-01-01     $10,000    $4,000     0.4x    -60%
2023-01-01     $10,000    $35,000    3.5x    250%
2024-01-01     $10,000    $50,000    5x      400%
2025-01-01     $10,000    待觀察      -       -
2026-03-22     $10,000    $45,000    4.5x    350%

* 假設初始價格為相應年份年初價格

風險評估模型：

class HODLRiskModel:
    def __init__(self, initial_investment, current_price, purchase_price):
        self.initial = initial_investment
        self.current = current_price
        self.purchase = purchase_price
        
    def unrealized_pnl(self):
        """計算未實現損益"""
        eth_amount = self.initial / self.purchase
        current_value = eth_amount * self.current
        return current_value - self.initial
    
    def return_percentage(self):
        """計算回報百分比"""
        return (self.current - self.purchase) / self.purchase * 100
    
    def maximum_drawdown_from_peak(self, peak_price):
        """計算從高點的回撤"""
        return (self.current - peak_price) / peak_price * 100
    
    def time_to_recover(self, daily_volatility, target_return=0):
        """估算恢復時間（蒙特卡羅模擬）"""
        simulations = 10000
        current_price = self.current
        recovery_count = 0
        
        for _ in range(simulations):
            price = current_price
            days = 0
            target = current_price * (1 + target_return)
            
            while days < 3650 and price < target:  # 最長10年
                price *= (1 + np.random.normal(0, daily_volatility))
                days += 1
                
            if price >= target:
                recovery_count += days
                
        return recovery_count / simulations if recovery_count > 0 else ">10 years"
    
    def risk_metrics(self):
        """計算完整風險指標"""
        daily_vol = 0.05  # ETH 日波動率約 5%
        
        return {
            'Unrealized P&L': f"${self.unrealized_pnl():,.2f}",
            'Return %': f"{self.return_percentage():.2f}%",
            'ETH Holdings': f"{self.initial/self.purchase:.4f} ETH",
            'Avg Recovery Time (est)': self.time_to_recover(daily_vol)
        }

HODL 策略適用對象：

• 投資期限 3 年以上的投資者
• 能承受 50% 以上回撤的風險承受能力
• 對以太坊長期價值有信心
• 不需要短期流動性

2.2 定投策略（Dollar Cost Averaging）

策略邏輯：

定投策略通過定期固定金額投資，降低時間點風險和情緒影響。對於波動性較高的資產，定投可以顯著降低平均購入成本。

定投計算模型：

class DCAStrategy:
    def __init__(self, initial_capital=0, monthly_investment=100, 
                 start_date='2020-01-01', end_date='2026-03-01'):
        self.initial = initial_capital
        self.monthly = monthly_investment
        self.start = pd.to_datetime(start_date)
        self.end = pd.to_datetime(end_date)
        self.portfolio = []
        
    def load_price_data(self):
        """載入歷史價格（需要真實數據）"""
        # 這裡使用模擬數據
        dates = pd.date_range(self.start, self.end, freq='M')
        # 模擬價格走勢（實際應用中使用真實數據）
        base_price = 150
        prices = [base_price * (1.1 ** (i/12) + np.random.normal(0, 0.1)) 
                  for i in range(len(dates))]
        return dict(zip(dates, prices))
    
    def calculate_dca(self):
        """計算定投結果"""
        prices = self.load_price_data()
        total_invested = self.initial
        total_eth = 0
        total_value = 0
        
        # 初始一次性投資
        if self.initial > 0:
            initial_price = list(prices.values())[0]
            total_eth = self.initial / initial_price
            
        # 月度定投
        for date, price in prices.items():
            total_invested += self.monthly
            total_eth += self.monthly / price
            total_value = total_eth * price
            
        avg_cost = total_invested / total_eth
        
        return {
            'Total Invested': total_invested,
            'Total ETH': total_eth,
            'Current Value': total_value,
            'Average Cost': avg_cost,
            'Total Return %': (total_value - total_invested) / total_invested * 100
        }
    
    def compare_lump_sum(self, current_price):
        """比較一次性投資與定投"""
        # 假設總投入相同
        months = (self.end - self.start).days / 30
        total_investment = self.initial + self.monthly * months
        
        # 一次性投資
        start_price = list(self.load_price_data().values())[0]
        lump_sum_eth = total_investment / start_price
        lump_sum_value = lump_sum_eth * current_price
        
        # 定投
        dca_result = self.calculate_dca()
        dca_value = dca_result['Total ETH'] * current_price
        
        return {
            'Lump Sum ETH': lump_sum_eth,
            'Lump Sum Value': lump_sum_value,
            'Lump Sum Return': (lump_sum_value - total_investment) / total_investment * 100,
            'DCA ETH': dca_result['Total ETH'],
            'DCA Value': dca_value,
            'DCA Return': dca_result['Total Return %'],
            'Difference': lump_sum_value - dca_value
        }

# 使用範例
dca = DCAStrategy(
    initial_capital=1000,
    monthly_investment=200,
    start_date='2020-01-01',
    end_date='2026-03-01'
)

print("=== DCA Strategy Results ===")
result = dca.calculate_dca()
for k, v in result.items():
    print(f"{k}: {v}")

定投參數優化：

def optimize_dca_parameters():
    """
    優化定投參數
    測試不同投資頻率和金額的效果
    """
    scenarios = []
    
    # 測試不同的月投資額
    for monthly in [50, 100, 200, 500, 1000]:
        dca = DCAStrategy(
            initial_capital=0,
            monthly_investment=monthly,
            start_date='2020-01-01',
            end_date='2026-03-01'
        )
        result = dca.calculate_dca()
        
        scenarios.append({
            'Monthly Investment': monthly,
            'Total Invested': result['Total Invested'],
            'Total ETH': result['Total ETH'],
            'Average Cost': result['Average Cost'],
            'Final Value': result['Current Value'],
            'Return %': result['Total Return %']
        })
        
    return pd.DataFrame(scenarios)

2.3 質押收益策略

質押收益計算模型：

class StakingYieldStrategy:
    def __init__(self, eth_holdings, annual_apr, compounding=True):
        self.eth = eth_holdings
        self.apr = annual_apr
        self.compounding = compounding
        
    def calculate_daily_yield(self):
        """計算日收益率"""
        if self.compounding:
            return (1 + self.apr) ** (1/365) - 1
        else:
            return self.apr / 365
    
    def project_value(self, years, price_growth=0):
        """預測未來價值"""
        daily_yield = self.calculate_daily_yield()
        days = years * 365
        
        # 計算複利收益
        eth_yield = self.eth * ((1 + daily_yield) ** days - 1)
        total_eth = self.eth + eth_yield
        
        # 計算價格變化
        final_price_factor = (1 + price_growth) ** years
        
        return {
            'Initial ETH': self.eth,
            'ETH from Yield': eth_yield,
            'Total ETH': total_eth,
            'ETH Value (no growth)': total_eth * 3000,  # 假設 $3000/ETH
            'ETH Value (with growth)': total_eth * 3000 * final_price_factor,
            'Total Yield %': eth_yield / self.eth * 100
        }
    
    def risk_adjusted_return(self, eth_volatility):
        """計算風險調整後收益"""
        # 質押收益的標準差（相對較低）
        yield_std = 0.001  # 日收益率標準差
        
        # 總回報
        total_return = self.apr + eth_volatility
        
        # 夏普比率
        risk_free = 0.03
        excess_return = total_return - risk_free
        total_volatility = np.sqrt(yield_std**2 + eth_volatility**2)
        
        sharpe = excess_return / total_volatility
        
        return {
            'Expected Return': total_return,
            'Total Volatility': total_volatility,
            'Sharpe Ratio': sharpe,
            'Yield Sharpe': self.apr / yield_std if yield_std > 0 else 0
        }

# 使用範例
staking = StakingYieldStrategy(
    eth_holdings=10.0,
    annual_apr=0.038,
    compounding=True
)

print("=== Staking Projection (5 years) ===")
projection = staking.project_value(5, price_growth=0.2)
for k, v in projection.items():
    print(f"{k}: {v}")

質押 vs 非質押比較：

def compare_staking_vs_holding():
    """
    比較質押與非質押的長期效果
    """
    initial_eth = 10.0
    current_price = 3000
    apr = 0.038
    years = 5
    price_scenarios = [0, 0.1, 0.2, 0.5]  # 年化價格增長率
    
    results = []
    
    for growth in price_scenarios:
        # 非質押
        holding_value = initial_eth * current_price * ((1 + growth) ** years)
        
        # 質押
        staking = StakingYieldStrategy(initial_eth, apr)
        staking_proj = staking.project_value(years, growth)
        staking_value = staking_proj['Total ETH'] * current_price * ((1 + growth) ** years)
        
        # 差異
        diff = staking_value - holding_value
        diff_pct = diff / holding_value * 100
        
        results.append({
            'Price Growth': f"{growth*100:.0f}%",
            'Holding Value': f"${holding_value:,.0f}",
            'Staking Value': f"${staking_value:,.0f}",
            'Difference': f"${diff:,.0f} ({diff_pct:.1f}%)"
        })
        
    return pd.DataFrame(results)

第三章：主動交易策略分析

3.1 技術分析策略

技術指標系統：

class EthereumTechnicalAnalysis:
    def __init__(self, prices_df):
        """
        初始化技術分析系統
        prices_df: 包含 'close', 'high', 'low', 'volume' 的 DataFrame
        """
        self.df = prices_df.copy()
        
    def sma(self, period):
        """簡單移動平均線"""
        return self.df['close'].rolling(window=period).mean()
    
    def ema(self, period):
        """指數移動平均線"""
        return self.df['close'].ewm(span=period, adjust=False).mean()
    
    def rsi(self, period=14):
        """相對強弱指數"""
        delta = self.df['close'].diff()
        gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
        rs = gain / loss
        return 100 - (100 / (1 + rs))
    
    def macd(self, fast=12, slow=26, signal=9):
        """MACD 指標"""
        ema_fast = self.ema(fast)
        ema_slow = self.ema(slow)
        macd_line = ema_fast - ema_slow
        signal_line = macd_line.ewm(span=signal, adjust=False).mean()
        histogram = macd_line - signal_line
        return {'macd': macd_line, 'signal': signal_line, 'histogram': histogram}
    
    def bollinger_bands(self, period=20, std_dev=2):
        """布林帶"""
        sma = self.sma(period)
        std = self.df['close'].rolling(window=period).std()
        upper = sma + (std * std_dev)
        lower = sma - (std * std_dev)
        return {'upper': upper, 'middle': sma, 'lower': lower}
    
    def atr(self, period=14):
        """平均真實波幅"""
        high_low = self.df['high'] - self.df['low']
        high_close = abs(self.df['high'] - self.df['close'].shift())
        low_close = abs(self.df['low'] - self.df['close'].shift())
        tr = pd.concat([high_low, high_close, low_close], axis=1).max(axis=1)
        return tr.rolling(window=period).mean()
    
    def generate_signals(self):
        """生成交易信號"""
        # 移動平均交叉策略
        self.df['sma_50'] = self.sma(50)
        self.df['sma_200'] = self.sma(200)
        
        # 買入信號：50 SMA 上穿 200 SMA
        self.df['sma_signal'] = 0
        self.df.loc[self.df['sma_50'] > self.df['sma_200'], 'sma_signal'] = 1
        self.df.loc[self.df['sma_50'] < self.df['sma_200'], 'sma_signal'] = -1
        
        # RSI 信號
        self.df['rsi'] = self.rsi()
        self.df['rsi_signal'] = 0
        self.df.loc[self.df['rsi'] < 30, 'rsi_signal'] = 1   # 超賣
        self.df.loc[self.df['rsi'] > 70, 'rsi_signal'] = -1  # 超買
        
        # MACD 信號
        macd = self.macd()
        self.df['macd'] = macd['macd']
        self.df['macd_signal'] = macd['signal']
        self.df['macd_hist'] = macd['histogram']
        
        # 綜合信號
        self.df['combined_signal'] = (
            self.df['sma_signal'] * 0.4 +
            self.df['rsi_signal'] * 0.3 +
            np.where(self.df['macd_hist'] > 0, 1, -1) * 0.3
        )
        
        return self.df

策略回測框架：

class StrategyBacktester:
    def __init__(self, initial_capital=10000, commission=0.001):
        self.capital = initial_capital
        self.initial = initial_capital
        self.commission = commission
        self.position = 0  # 持倉 ETH 數量
        self.trades = []
        
    def backtest(self, df, signal_column, stop_loss=0.05, take_profit=0.15):
        """
        回測策略
        signal_column: 信號列名
        stop_loss: 止損比例
        take_profit: 止盈比例
        """
        entry_price = 0
        peak_price = 0
        
        for i in range(len(df)):
            price = df.iloc[i]['close']
            signal = df.iloc[i][signal_column]
            
            if signal == 1 and self.position == 0:  # 買入
                # 計算可買入數量
                buy_amount = self.capital * (1 - self.commission) / price
                self.position = buy_amount
                self.capital = 0
                entry_price = price
                peak_price = price
                self.trades.append({
                    'type': 'BUY',
                    'price': price,
                    'position': self.position,
                    'date': df.iloc[i].name
                })
                
            elif signal == -1 and self.position > 0:  # 賣出
                self.capital = self.position * price * (1 - self.commission)
                self.trades.append({
                    'type': 'SELL',
                    'price': price,
                    'return': (price - entry_price) / entry_price,
                    'date': df.iloc[i].name
                })
                self.position = 0
                
            elif self.position > 0:  # 持倉管理
                peak_price = max(peak_price, price)
                
                # 止損檢查
                if price < entry_price * (1 - stop_loss):
                    self.capital = self.position * price * (1 - self.commission)
                    self.trades.append({
                        'type': 'STOP_LOSS',
                        'price': price,
                        'return': -stop_loss,
                        'date': df.iloc[i].name
                    })
                    self.position = 0
                    
                # 止盈檢查
                elif price > entry_price * (1 + take_profit):
                    self.capital = self.position * price * (1 - self.commission)
                    self.trades.append({
                        'type': 'TAKE_PROFIT',
                        'price': price,
                        'return': take_profit,
                        'date': df.iloc[i].name
                    })
                    self.position = 0
        
        # 計算最終價值
        final_value = self.capital + self.position * df.iloc[-1]['close']
        
        return {
            'Initial Capital': self.initial,
            'Final Value': final_value,
            'Total Return': (final_value - self.initial) / self.initial,
            'Number of Trades': len(self.trades),
            'Trades': self.trades
        }

3.2 期現套利策略

Cash and Carry 套利模型：

class CashCarryArbitrage:
    def __init__(self):
        self.funding_rate = 0.05  # 期貨資金利率
        
    def calculate_arbitrage(self, spot_price, futures_price, days_to_expiry, 
                           borrow_rate=0.08, storage_rate=0.0):
        """
        計算期現套利收益
        
        參數:
        - spot_price: 現貨價格
        - futures_price: 期貨價格
        - days_to_expiry: 到期天數
        - borrow_rate: 借入利率 (年化)
        - storage_rate: 倉儲費率 (年化)
        """
        # 資金成本
        daily_borrow_cost = spot_price * (borrow_rate / 365)
        daily_storage_cost = spot_price * (storage_rate / 365)
        
        # 持有成本總計
        total_holding_cost = (daily_borrow_cost + daily_storage_cost) * days_to_expiry
        
        # 期貨到期收益
        futures_proceeds = futures_price - spot_price
        
        # 扣除成本後的淨收益
        net_proceeds = futures_proceeds - total_holding_cost
        
        # 年化收益率
        annual_return = (net_proceeds / spot_price) * (365 / days_to_expiry)
        
        # 風險分析
        risks = {
            'spot_price_drop': spot_price * 0.5,  # 假設最大下跌 50%
            'liquidation_price': spot_price * 0.8,  # 保證金強平價
            'funding_rate_change': abs(self.funding_rate - 0.05)
        }
        
        return {
            'Spot Price': f"${spot_price:,.2f}",
            'Futures Price': f"${futures_price:,.2f}",
            'Basis': f"${futures_proceeds:,.2f}",
            'Holding Cost': f"${total_holding_cost:,.2f}",
            'Net Proceeds': f"${net_proceeds:,.2f}",
            'Annualized Return': f"{annual_return*100:.2f}%",
            'Risks': risks
        }
    
    def perpetual_futures_arbitrage(self, spot_price, perp_price, funding_rate):
        """
        永續期貨套利計算
        
        由於永續期貨每 8 小時支付資金費
        """
        # 資金費收益
        hours_per_period = 8
        periods_per_day = 3  # 24/8
        daily_funding = funding_rate / 365 * periods_per_day
        
        # 借入 USDT，購買現貨，存入期貨空頭
        # 收益 = 資金費 - 借入成本
        
        daily_return = daily_funding - (spot_price * 0.08 / 365)  # 假設借入利率 8%
        annual_return = daily_return * 365
        
        return {
            'Daily Funding Rate': f"{daily_funding*100:.4f}%",
            'Daily Return': f"{daily_return*100:.4f}%",
            'Annual Return (approx)': f"{annual_return*100:.2f}%"
        }

# 使用範例
arb = CashCarryArbitrage()

print("=== Cash & Carry Arbitrage ===")
result = arb.calculate_arbitrage(
    spot_price=3000,
    futures_price=3150,
    days_to_expiry=90,
    borrow_rate=0.08
)
for k, v in result.items():
    if k != 'Risks':
        print(f"{k}: {v}")

第四章：DeFi 收益策略

4.1 借貸收益策略

class DeFiLendingStrategy:
    def __init__(self, initial_capital, eth_price):
        self.capital = initial_capital
        self.eth_price = eth_price
        
    def aave_v3_strategy(self):
        """
        Aave V3 借貸策略
        存入 ETH 借出 USDC
        """
        # 假設 ETH 質押存款利率
        eth_deposit_apr = 0.015  # 1.5%
        
        # 借出 USDC (假設利率)
        usdc_borrow_apr = 0.045  # 4.5%
        
        # 計算借款額度 (ETH 作為抵押品)
        # Aave V3 ETH LTV 通常為 80%
        max_ltv = 0.80
        
        # 可借款額度
        borrow_amount = self.capital * max_ltv
        
        # 收益計算
        # 1. 存款 ETH 收益
        deposit_yield = self.capital * eth_deposit_apr
        
        # 2. 借款成本
        borrow_cost = borrow_amount * usdc_borrow_apr
        
        # 3. 淨收益
        net_yield = deposit_yield - borrow_cost
        
        # 4. 風險：ETH 價格下跌導致清算
        # 清算閾值 (保持 85% 健康係數)
        liquidation_threshold = 1 / (max_ltv * 1.05)
        
        return {
            'Strategy': 'Aave V3 ETH/USDC',
            'Initial ETH': self.capital / self.eth_price,
            'Deposit APR': f"{eth_deposit_apr*100:.2f}%",
            'Borrow APR': f"{usdc_borrow_apr*100:.2f}%",
            'Gross Yield': f"${deposit_yield:.2f}",
            'Borrow Cost': f"${borrow_cost:.2f}",
            'Net Yield': f"${net_yield:.2f}",
            'Net APR': f"{net_yield/self.capital*100:.2f}%",
            'Liquidation Risk': f"ETH > {liquidation_threshold*100:.0f}% drop"
        }
    
    def compound_strategy(self):
        """
        Compound Finance 策略
        """
        c_eth_supply_apr = 0.020  # 2%
        c_usdc_borrow_apr = 0.040  # 4%
        
        # 策略計算（與 Aave 類似）
        deposit_yield = self.capital * c_eth_supply_apr
        max_borrow = self.capital * 0.75  # Compound LTV 75%
        borrow_cost = max_borrow * c_usdc_borrow_apr
        net = deposit_yield - borrow_cost
        
        return {
            'Strategy': 'Compound ETH/USDC',
            'Net APR': f"{net/self.capital*100:.2f}%"
        }

4.2 流動性提供策略

class LiquidityProvisionStrategy:
    def __init__(self, eth_amount, usdc_amount, eth_price):
        self.eth = eth_amount
        self.usdc = usdc_amount
        self.eth_price = eth_price
        self.total_value = eth_amount * eth_price + usdc_amount
        
    def calculate_impermanent_loss(self, price_change_ratio):
        """
        計算無常損失
        
        price_change_ratio: 價格變化倍數 (如 2 = 價格翻倍)
        """
        sqrt_price = np.sqrt(price_change_ratio)
        
        # 無常損失公式
        il = (2 * sqrt_price / (1 + price_change_ratio)) - 1
        
        return abs(il)
    
    def univ2_lp_strategy(self, fee_tier=0.003):
        """
        Uniswap V2 流動性池策略
        
        假設 ETH/USDC 流動性池
        """
        # 每日交易量（假設）
        daily_volume = 1000000  # $1M
        
        # 費率收入
        fee_revenue = daily_volume * fee_tier * 365
        
        # LP 佔比（假設總流動性）
        total_liquidity = 10000000  # $10M
        self_share = self.total_value / total_liquidity
        
        # LP 獲得的費用
        lp_fees = fee_revenue * self_share
        
        # 計算不同價格情景的無常損失
        scenarios = []
        for change in [-0.5, -0.3, 0, 0.3, 0.5, 1.0, 2.0]:
            price_ratio = 1 + change
            il = self.calculate_impermanent_loss(price_ratio)
            il_cost = self.total_value * il
            
            # 費率收益 vs 無常損失
            net = lp_fees - il_cost
            
            scenarios.append({
                'Price Change': f"{change*100:.0f}%",
                'Impermanent Loss': f"${il_cost:,.0f}",
                'Fee Revenue': f"${lp_fees:,.0f}",
                'Net': f"${net:,.0f}"
            })
            
        return pd.DataFrame(scenarios)

第五章：量化策略框架

5.1 機器學習預測模型

class MLPricePredictor:
    def __init__(self, lookback_periods=30):
        self.lookback = lookback_periods
        
    def create_features(self, df):
        """創建特徵矩陣"""
        features = pd.DataFrame()
        
        # 價格特徵
        features['returns'] = df['close'].pct_change()
        features['log_returns'] = np.log(df['close'] / df['close'].shift(1))
        
        # 移動平均
        for period in [7, 14, 30, 60]:
            features[f'sma_{period}'] = df['close'].rolling(period).mean()
            features[f'ema_{period}'] = df['close'].ewm(span=period).mean().mean()
            
        # 波動率特徵
        for period in [7, 14, 30]:
            features[f'volatility_{period}'] = df['close'].pct_change().rolling(period).std()
            
        # RSI
        delta = df['close'].diff()
        gain = delta.where(delta > 0, 0).rolling(14).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(14).mean()
        rs = gain / loss
        features['rsi'] = 100 - (100 / (1 + rs))
        
        # MACD
        ema12 = df['close'].ewm(span=12).mean()
        ema26 = df['close'].ewm(span=26).mean()
        features['macd'] = ema12 - ema26
        features['macd_signal'] = features['macd'].ewm(span=9).mean()
        
        # 成交量特徵
        features['volume_sma'] = df['volume'].rolling(20).mean()
        features['volume_ratio'] = df['volume'] / features['volume_sma']
        
        return features.dropna()
    
    def train_model(self, df):
        """訓練預測模型"""
        from sklearn.ensemble import RandomForestClassifier
        from sklearn.model_selection import train_test_split
        
        # 創建標籤（次日漲跌）
        features = self.create_features(df)
        labels = (df['close'].shift(-1) > df['close']).astype(int)
        labels = labels.dropna()
        
        # 對齊
        features = features.iloc[:len(labels)]
        
        # 分割數據
        X_train, X_test, y_train, y_test = train_test_split(
            features, labels, test_size=0.2, random_state=42
        )
        
        # 訓練隨機森林
        model = RandomForestClassifier(
            n_estimators=100,
            max_depth=10,
            random_state=42
        )
        model.fit(X_train, y_train)
        
        # 評估
        train_score = model.score(X_train, y_train)
        test_score = model.score(X_test, y_test)
        
        return {
            'model': model,
            'train_accuracy': train_score,
            'test_accuracy': test_score,
            'feature_importance': dict(zip(
                features.columns, 
                model.feature_importances_
            ))
        }

第六章：策略組合與優化

6.1 投資組合優化

class PortfolioOptimizer:
    def __init__(self):
        self.strategies = {
            'HODL': {'return': 0.30, 'volatility': 0.80, 'weight': 0},
            'DCA': {'return': 0.25, 'volatility': 0.60, 'weight': 0},
            'Staking': {'return': 0.08, 'volatility': 0.65, 'weight': 0},
            'DeFi_Lending': {'return': 0.12, 'volatility': 0.50, 'weight': 0},
            'LP': {'return': 0.20, 'volatility': 0.70, 'weight': 0},
            'Arbitrage': {'return': 0.15, 'volatility': 0.20, 'weight': 0}
        }
        
    def calculate_portfolio_metrics(self, weights):
        """計算投資組合風險收益"""
        weighted_return = sum(
            self.strategies[s]['return'] * w 
            for s, w in zip(self.strategies.keys(), weights)
        )
        
        # 假設相關係數矩陣（簡化）
        # 實際應用中需要計算真實相關性
        correlations = self._get_correlation_matrix()
        
        # 計算組合波動率
        portfolio_variance = 0
        for i, (s1, w1) in enumerate(zip(self.strategies.keys(), weights)):
            for j, (s2, w2) in enumerate(zip(self.strategies.keys(), weights)):
                vol1 = self.strategies[s1]['volatility']
                vol2 = self.strategies[s2]['volatility']
                portfolio_variance += w1 * w2 * vol1 * vol2 * correlations[i][j]
                
        portfolio_volatility = np.sqrt(portfolio_variance)
        sharpe = (weighted_return - 0.03) / portfolio_volatility
        
        return {
            'portfolio_return': weighted_return,
            'portfolio_volatility': portfolio_volatility,
            'sharpe_ratio': sharpe,
            'weights': dict(zip(self.strategies.keys(), weights))
        }
    
    def optimize_sharpe(self):
        """優化夏普比率"""
        from scipy.optimize import minimize
        
        n_strategies = len(self.strategies)
        
        # 約束：權重之和為1
        constraints = {'type': 'eq', 'fun': lambda x: np.sum(x) - 1}
        
        # 邊界：每個權重 0-100%
        bounds = [(0, 1) for _ in range(n_strategies)]
        
        # 目標函數：負夏普比率（最小化）
        def objective(weights):
            metrics = self.calculate_portfolio_metrics(weights)
            return -metrics['sharpe_ratio']
        
        # 初始猜測
        x0 = np.ones(n_strategies) / n_strategies
        
        # 優化
        result = minimize(objective, x0, method='SLSQP', 
                         bounds=bounds, constraints=constraints)
        
        return self.calculate_portfolio_metrics(result.x)
    
    def _get_correlation_matrix(self):
        """生成策略相關係數矩陣"""
        strategies = list(self.strategies.keys())
        n = len(strategies)
        corr = np.ones((n, n))
        
        # 設定相關性
        # HODL, DCA 高度相關
        # Staking 與 HODL 相關
        # Arbitrage 與其他低相關
        
        for i in range(n):
            for j in range(n):
                if strategies[i] in ['HODL', 'DCA'] and strategies[j] in ['HODL', 'DCA']:
                    corr[i][j] = 0.95
                elif strategies[i] == 'Arbitrage':
                    corr[i][j] = 0.1
                elif strategies[j] == 'Arbitrage':
                    corr[i][j] = 0.1
                    
        return corr

# 使用範例
optimizer = PortfolioOptimizer()

print("=== Optimal Portfolio ===")
optimal = optimizer.optimize_sharpe()
print(f"Expected Return: {optimal['portfolio_return']*100:.2f}%")
print(f"Portfolio Volatility: {optimal['portfolio_volatility']*100:.2f}%")
print(f"Sharpe Ratio: {optimal['sharpe_ratio']:.3f}")
print("\nOptimal Weights:")
for strategy, weight in optimal['weights'].items():
    if weight > 0.01:
        print(f"  {strategy}: {weight*100:.1f}%")

總結與策略選擇建議

策略選擇矩陣：

關鍵原則：

1. 分散投資：不要把所有資金放在單一策略
2. 風險控制：設定止損和部位上限
3. 持續學習：市場和技術持續演進
4. 流動性管理：保持足夠的應急資金
5. 稅務規劃：了解各地區的加密貨幣稅務規定

免責聲明

本分析僅供教育目的，不構成投資建議。加密貨幣投資涉及高風險，請在充分了解後謹慎決策。過去的表現不代表未來結果。