Thuật toán của Jim Simons kiếm tiền trong lúc bạn ngủ như thế nào (Khung định lượng chi tiết)

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    # Tự tương quan — lợi nhuận hôm nay có dự đoán được lợi nhuận ngày mai không?
9    acf_1 = returns.autocorr(lag=1)
10
11    # Độ lệch Z so với trung bình động
12    rolling_mean = returns.rolling(lookback).mean()
13    rolling_std  = returns.rolling(lookback).std()
14    z_score      = (returns - rolling_mean) / rolling_std
15
16    # Số mũ Hurst — chuỗi này đang có xu hướng hay quay về giá trị trung bình?
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 = quay về giá trị trung bình, >0.5 = đang có xu hướng
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 lợi nhuận của tài sản
6    factors: DataFrame lợi nhuận của các nhân tố (thị trường, quy mô, giá trị, động lượng, v.v.)
7    """
8    model = LinearRegression()
9    model.fit(factors, returns)
10
11    alpha     = model.intercept_          # Lợi nhuận không được giải thích bởi nhân tố = lợi thế thuần
12    betas     = model.coef_               # Mức độ tiếp xúc với nhân tố
13    r_squared = model.score(factors, returns)
14
15    return {
16        "alpha": alpha,    # Đây là thứ bạn đang săn tìm — alpha có > 0 không?
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# Các trạng thái: 0=Tăng giá, 1=Giảm giá, 2=Trì trệ
4# Ma trận chuyển đổi được ước tính từ dữ liệu lịch sử
5transition_matrix = np.array([
6    [0.78, 0.14, 0.08],  # Từ Tăng giá: 78% ở lại Tăng giá, 14% chuyển sang Giảm giá, 8% Trì trệ
7    [0.20, 0.68, 0.12],  # Từ Giảm giá: 20% phục hồi, 68% ở lại Giảm giá, 12% Trì trệ
8    [0.25, 0.23, 0.52],  # Từ Trì trệ: 25% Tăng giá, 23% Giảm giá, 52% ở lại
9])
10
11def get_next_regime(current_state: int, steps: int = 5) -> np.ndarray:
12    """Trả về phân phối xác suất trên các trạng thái sau N bước."""
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":      ["Bull", "Bear", "Stagnant"][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)    # Đầu ra: xác suất [mua dài, bán khống, giữ]
14        )
15
16    def forward(self, x):
17        return torch.softmax(self.layers(x), dim=-1)
18
19# Tín hiệu huấn luyện: kết hợp điểm nhân tố + xác suất chế độ + đặc điểm giá thô
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 lợi nhuận gần nhất
24        list(factors.values()),                 # Mức độ tiếp xúc với nhân tố
25        list(regime_probs.values()),            # Xác suất chế độ 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   # Không bao giờ rủi ro quá 2% cho mỗi giao dịch
5) -> float:
6    kelly_fraction = win_probability - (1 - win_probability) / win_loss_ratio
7    kelly_fraction = max(0, kelly_fraction)             # Không bao giờ short Kelly
8    half_kelly      = kelly_fraction * 0.5              # Sử dụng nửa Kelly để an toàn
9    return min(half_kelly, max_risk_pct)                # Giới hạn cứng ở 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# Chỉ thực hiện giao dịch nếu lợi thế > chi phí thực thi
22def should_trade(edge_bps: float, execution_cost_bps: float) -> bool:
23    return edge_bps > (execution_cost_bps * 1.5)   # Yêu cầu bù đắp chi phí tối thiểu 1.5x

1Dữ liệu thị trường thô
2      ↓
3[L1] Phát hiện tín hiệu  → Hurst · ACF · Z-score
4      ↓
5[L2] Mô hình nhân tố     → Trích xuất α · Tiếp xúc β
6      ↓
7[L3] Chế độ Markov      → Tăng giá · Giảm giá · Trì trệ
8      ↓
9[L4] Lợi thế mạng nơ-ron    → Mua dài · Bán khống · Giữ
10      ↓
11[L5] Kelly + Thực thi   → Kích thước vị thế · Bộ lọc chi phí · Nhập lệnh
12      ↓
13    Giao dịch / Không giao dịch