วิธีที่อัลกอริทึมของ Jim Simons ทำเงินให้คุณในขณะที่คุณหลับ (เจาะลึก Quant Framework ฉบับสมบูรณ์)

1import numpy as np
2import pandas as pd
3from scipy import stats
4
5def detect_signal(prices: pd.Series, lookback: int = 20) -> dict:
6    returns = prices.pct_change().dropna()
7
8    # Autocorrelation — ผลตอบแทนวันนี้ทำนายวันพรุ่งนี้ได้ไหม?
9    acf_1 = returns.autocorr(lag=1)
10
11    # ค่าเบี่ยงเบน Z-score จากค่าเฉลี่ยเคลื่อนที่
12    rolling_mean = returns.rolling(lookback).mean()
13    rolling_std  = returns.rolling(lookback).std()
14    z_score      = (returns - rolling_mean) / rolling_std
15
16    # Hurst exponent — อนุกรมนี้มีแนวโน้มหรือกลับสู่ค่าเฉลี่ย?
17    hurst = compute_hurst(prices.values)
18
19    return {
20        "autocorrelation": acf_1,
21        "z_score_latest": z_score.iloc[-1],
22        "hurst_exponent": hurst,   # <0.5 = กลับสู่ค่าเฉลี่ย, >0.5 = มีแนวโน้ม
23        "regime": "trending" if hurst > 0.55 else "mean_reverting"
24    }
25
26def compute_hurst(ts):
27    lags = range(2, 20)
28    tau  = [np.sqrt(np.std(np.subtract(ts[lag:], ts[:-lag]))) for lag in lags]
29    m    = np.polyfit(np.log(lags), np.log(tau), 1)
30    return m[0] * 2.0

1from sklearn.linear_model import LinearRegression
2
3def factor_decompose(returns: pd.DataFrame, factors: pd.DataFrame) -> dict:
4    """
5    returns: DataFrame ของผลตอบแทนสินทรัพย์
6    factors: DataFrame ของผลตอบแทนปัจจัย (ตลาด, ขนาด, มูลค่า, โมเมนตัม ฯลฯ)
7    """
8    model = LinearRegression()
9    model.fit(factors, returns)
10
11    alpha     = model.intercept_          # ผลตอบแทนที่ไม่สามารถอธิบายด้วยปัจจัย = ขอบล้วน
12    betas     = model.coef_               # การเปิดรับปัจจัย
13    r_squared = model.score(factors, returns)
14
15    return {
16        "alpha": alpha,    # นี่คือสิ่งที่คุณตามล่า — alpha > 0 หรือไม่?
17        "betas": dict(zip(factors.columns, betas)),
18        "r_squared": r_squared,
19        "edge_quality": "strong" if abs(alpha) > 0.001 and r_squared > 0.3 else "weak"
20    }

1import numpy as np
2
3# สถานะ: 0=กระทิง, 1=หมี, 2=ซบเซา
4# เมทริกซ์การเปลี่ยนที่ประมาณจากข้อมูลในอดีต
5transition_matrix = np.array([
6    [0.78, 0.14, 0.08],  # จากกระทิง: 78% ยังคงกระทิง, 14% ไปหมี, 8% ซบเซา
7    [0.20, 0.68, 0.12],  # จากหมี: 20% ฟื้นตัว, 68% ยังคงหมี, 12% ซบเซา
8    [0.25, 0.23, 0.52],  # จากซบเซา: 25% กระทิง, 23% หมี, 52% ยังคง
9])
10
11def get_next_regime(current_state: int, steps: int = 5) -> np.ndarray:
12    """ส่งกลับการแจกแจงความน่าจะเป็นเหนือสถานะหลังจาก N ขั้นตอน."""
13    state_vec = np.zeros(3)
14    state_vec[current_state] = 1.0
15
16    for _ in range(steps):
17        state_vec = state_vec @ transition_matrix
18
19    return {
20        "bull_probability":     round(state_vec[0], 3),
21        "bear_probability":     round(state_vec[1], 3),
22        "stagnant_probability": round(state_vec[2], 3),
23        "dominant_regime":      ["กระทิง", "หมี", "ซบเซา"][np.argmax(state_vec)]
24    }

1import torch
2import torch.nn as nn
3
4class QuantEdgeNet(nn.Module):
5    def __init__(self, input_features: int = 50):
6        super().__init__()
7        self.layers = nn.Sequential(
8            nn.Linear(input_features, 128),
9            nn.ReLU(),
10            nn.Dropout(0.2),
11            nn.Linear(128, 64),
12            nn.ReLU(),
13            nn.Linear(64, 3)    # เอาต์พุต: ความน่าจะเป็น [long, short, flat]
14        )
15
16    def forward(self, x):
17        return torch.softmax(self.layers(x), dim=-1)
18
19# สัญญาณฝึก: รวมคะแนนปัจจัย + ความน่าจะเป็นสภาวะ + คุณลักษณะราคาดิบ
20def build_feature_vector(prices, factors, regime_probs):
21    signal = detect_signal(prices)
22    return np.concatenate([
23        prices.pct_change().tail(20).values,   # 20 ผลตอบแทนล่าสุด
24        list(factors.values()),                 # การเปิดรับปัจจัย
25        list(regime_probs.values()),            # ความน่าจะเป็นสภาวะ Markov
26        [signal["hurst_exponent"],
27         signal["z_score_latest"]]
28    ])

1def kelly_position_size(
2    win_probability: float,
3    win_loss_ratio:  float,
4    max_risk_pct:    float = 0.02   # อย่าเสี่ยงมากกว่า 2% ต่อการเทรด
5) -> float:
6    kelly_fraction = win_probability - (1 - win_probability) / win_loss_ratio
7    kelly_fraction = max(0, kelly_fraction)             # อย่า Kelly สั้น
8    half_kelly      = kelly_fraction * 0.5              # ใช้ half-Kelly เพื่อความปลอดภัย
9    return min(half_kelly, max_risk_pct)                # จำกัดสูงสุดที่ 2%
10
11def calculate_execution_cost(
12    spread_bps: float,
13    market_impact_bps: float,
14    shares: int,
15    price: float
16) -> float:
17    total_bps    = spread_bps + market_impact_bps
18    cost_per_share = price * total_bps / 10_000
19    return cost_per_share * shares
20
21# เทรดเมื่อขอบมากกว่าต้นทุนการดำเนินการ
22def should_trade(edge_bps: float, execution_cost_bps: float) -> bool:
23    return edge_bps > (execution_cost_bps * 1.5)   # ต้องการครอบคลุมต้นทุนขั้นต่ำ 1.5 เท่า

1ข้อมูลตลาดดิบ
2      ↓
3[L1] การตรวจจับสัญญาณ   → Hurst · ACF · Z-score
4      ↓
5[L2] โมเดลปัจจัย       → การสกัด α · การเปิดรับ β
6      ↓
7[L3] สภาวะ Markov      → กระทิง · หมี · ซบเซา
8      ↓
9[L4] ขอบโครงข่ายประสาท  → Long · Short · Flat
10      ↓
11[L5] Kelly + การดำเนินการ → ขนาดตำแหน่ง · ตัวกรองต้นทุน · การเข้า
12      ↓
13    เทรด / ไม่เทรด