de-shaw-computational-finance について
de-shaw-computational-financeは、定量金融に体系的な研究とエンジニアリングの原則を適用するガイドです。取引システムを構築する開発者向けに、仮説検証、リスク分析、再現可能な研究、モジュール型戦略を扱います。
主な機能
- 01研究仮説の設定と検証
- 02アルファ研究と執行の分離
- 03多因子リスク分析の適用
- 04再現可能な研究パイプラインの構築
- 05モジュール型コンポーネントによる戦略構成
活用シーン
- 01体系的な取引研究パイプラインの設計
- 02アウトオブサンプル検証による戦略評価
- 03ポートフォリオのリスク分析の構成
- 04定量実験の記録と再現
インストール
コマンドをコピーしてターミナルで実行します。
$
npx skills add https:/インストール後、Claude Code で/de-shaw-computational-financeを入力して読み込まれたか確認します。
詳細
D.E. Shaw スタイルガイド
概要
コンピューター科学者の David E. Shaw が 1988 年に設立した D.E. Shaw は、最初期のクオンツ・ヘッジファンドのひとつです。同社は、金融に計算手法を応用する先駆者として、取引を科学および工学の問題として捉えてきました。同社は約 600 億ドルを運用し、卓越した技術者や科学者を採用することで知られています。
基本理念
「金融の問題にも、科学者が物理学や生物学の問題に取り組むのと同じ方法で取り組みます。」
「優れたアイデアは、金融の専門家ではない人から生まれることがよくあります。」
「テクノロジーはコストセンターではなく、競争上の優位性です。」
D.E. Shaw は、金融は本質的に計算の問題だと考えています。厳密な科学的手法と世界水準のテクノロジーを活用することで、システマティックなアプローチは裁量的なアプローチを上回る成果を上げられます。
設計原則
-
直感より科学：仮説を立て、検証し、妥当性を確認するか、棄却します。
-
リサーチ基盤：プラットフォームはリサーチを可能にするものであり、その逆ではありません。
-
ジェネラリストを採用する：優れたクオンツが必ずしも金融出身とは限りません。
-
長期的な視点：何十年にもわたって機能するシステムを構築します。
-
まずリスクを考える：何がうまくいくかを考える前に、何がうまくいかない可能性があるかを理解します。
システマティック取引システムを構築する際
必ず行うこと
- 明確で検証可能な仮説を立てる
- アルファのリサーチと執行を分離する
- すべてのレイヤーに堅牢なリスク管理を組み込む
- コード、データ、モデル、設定など、すべてをバージョン管理する
- 拡張性と保守性を考慮して設計する
- 前提条件と制約事項を文書化する
決して行わないこと
- 実証的な検証なしに直感に頼る
- インサンプルとアウトオブサンプルのパフォーマンスを混同する
- レジーム変化や構造的な断絶を無視する
- 相関関係が安定していると仮定する
- 十分なテストをせずにデプロイする
- 単一の指標に合わせて最適化する
推奨すること
- モジュール化され、組み合わせ可能なアーキテクチャ
- 責務の明確な分離
- 再現可能なリサーチパイプライン
- 防御的なプログラミング手法
- 詳細なログ記録とモニタリング
- キルスイッチを備えた段階的なロールアウト
コードパターン
リサーチパイプラインのアーキテクチャ
class ResearchPipeline:
"""
D.E. Shaw's approach: systematic research with reproducibility.
Every experiment is tracked, versioned, and reproducible.
"""
def __init__(self, experiment_tracker, data_warehouse, compute_cluster):
self.tracker = experiment_tracker
self.data = data_warehouse
self.compute = compute_cluster
def run_experiment(self,
hypothesis: Hypothesis,
config: ExperimentConfig) -> ExperimentResult:
"""
Run a single experiment with full tracking.
"""
# Create experiment record
experiment_id = self.tracker.create_experiment(
hypothesis=hypothesis.description,
config=config.to_dict(),
git_commit=get_git_commit(),
data_version=self.data.get_version()
)
try:
# Load data with point-in-time correctness
data = self.data.load(
universe=config.universe,
start_date=config.start_date,
end_date=config.end_date,
as_of_date=config.as_of_date # Prevent lookahead
)
# Validate data quality
quality_report = self.validate_data(data)
self.tracker.log_artifact(experiment_id, 'data_quality', quality_report)
# Run the actual analysis
result = hypothesis.evaluate(data, config)
# Compute statistical significance
significance = self.assess_significance(result, config)
# Log results
self.tracker.log_metrics(experiment_id, {
'sharpe_ratio': result.sharpe_ratio,
'information_ratio': result.information_ratio,
't_statistic': significance.t_stat,
'p_value': significance.p_value,
'num_observations': result.n_obs
})
return ExperimentResult(
experiment_id=experiment_id,
hypothesis=hypothesis,
result=result,
significance=significance,
reproducible=True
)
except Exception as e:
self.tracker.log_failure(experiment_id, str(e))
raise
def run_hypothesis_suite(self,
hypotheses: List[Hypothesis],
config: ExperimentConfig) -> SuiteResult:
"""
Run multiple hypotheses and correct for multiple testing.
"""
results = []
for hypothesis in hypotheses:
result = self.run_experiment(hypothesis, config)
results.append(result)
# Apply Benjamini-Hochberg FDR correction
corrected = self.apply_fdr_correction(results)
return SuiteResult(
results=corrected,
significant_count=sum(1 for r in corrected if r.is_significant),
total_count=len(corrected)
)
多因子リスクモデル
class RiskModel:
"""
D.E. Shaw's risk approach: understand and control risk at multiple levels.
"""
def __init__(self, factor_returns, factor_covariance, specific_risk):
self.factor_returns = factor_returns # Historical factor returns
self.factor_cov = factor_covariance # Factor covariance matrix
self.specific_risk = specific_risk # Idiosyncratic risk by asset
def estimate_portfolio_risk(self,
positions: pd.Series,
factor_exposures: pd.DataFrame) -> RiskEstimate:
"""
Decompose portfolio risk into systematic and idiosyncratic components.
"""
# Factor risk: w' * B * Σ_f * B' * w
portfolio_exposures = factor_exposures.T @ positions
factor_var = portfolio_exposures @ self.factor_cov @ portfolio_exposures
# Specific risk: Σ(w_i^2 * σ_i^2)
specific_var = (positions ** 2 * self.specific_risk ** 2).sum()
# Total risk
total_var = factor_var + specific_var
return RiskEstimate(
total_volatility=np.sqrt(total_var * 252), # Annualized
factor_volatility=np.sqrt(factor_var * 252),
specific_volatility=np.sqrt(specific_var * 252),
factor_contribution=self.calculate_factor_contributions(
positions, factor_exposures
)
)
def calculate_factor_contributions(self, positions, factor_exposures):
"""
Break down risk by factor for attribution.
"""
portfolio_exposures = factor_exposures.T @ positions
contributions = {}
for factor in self.factor_cov.columns:
# Marginal contribution to risk
factor_exposure = portfolio_exposures[factor]
factor_vol = np.sqrt(self.factor_cov.loc[factor, factor])
contributions[factor] = {
'exposure': factor_exposure,
'volatility': factor_vol,
'contribution': factor_exposure * factor_vol
}
return contributions
def stress_test(self,
positions: pd.Series,
scenarios: Dict[str, Dict[str, float]]) -> Dict[str, float]:
"""
Apply historical or hypothetical stress scenarios.
"""
results = {}
for scenario_name, factor_shocks in scenarios.items():
pnl = 0.0
for factor, shock in factor_shocks.items():
factor_exposure = self.get_portfolio_exposure(positions, factor)
pnl += factor_exposure * shock
results[scenario_name] = pnl
return results
戦略構成フレームワーク
class StrategyFramework:
"""
D.E. Shaw's modular strategy architecture.
Strategies are composed from reusable components.
"""
def __init__(self):
self.alpha_models = {}
self.risk_models = {}
self.execution_models = {}
self.portfolio_constructors = {}
def register_alpha_model(self, name: str, model: AlphaModel):
"""Alpha models generate return predictions."""
self.alpha_models[name] = model
def register_risk_model(self, name: str, model: RiskModel):
"""Risk models estimate covariances and factor exposures."""
self.risk_models[name] = model
def create_strategy(self, config: StrategyConfig) -> Strategy:
"""
Compose a strategy from registered components.
"""
alpha = self.alpha_models[config.alpha_model]
risk = self.risk_models[config.risk_model]
execution = self.execution_models[config.execution_model]
constructor = self.portfolio_constructors[config.portfolio_constructor]
return ComposedStrategy(
alpha_model=alpha,
risk_model=risk,
execution_model=execution,
portfolio_constructor=constructor,
constraints=config.constraints,
risk_limits=config.risk_limits
)
class ComposedStrategy:
"""
A strategy composed from modular components.
"""
def __init__(self, alpha_model, risk_model, execution_model,
portfolio_constructor, constraints, risk_limits):
self.alpha = alpha_model
self.risk = risk_model
self.execution = execution_model
self.constructor = portfolio_constructor
self.constraints = constraints
self.risk_limits = risk_limits
def generate_trades(self,
current_positions: pd.Series,
market_data: MarketData) -> List[Trade]:
"""
Full strategy pipeline: alpha → portfolio → trades.
"""
# 1. Generate alpha signals
alpha_scores = self.alpha.predict(market_data)
# 2. Estimate risk
risk_estimate = self.risk.estimate(market_data)
# 3. Construct optimal portfolio
target_positions = self.constructor.optimize(
alpha_scores=alpha_scores,
risk_model=risk_estimate,
current_positions=current_positions,
constraints=self.constraints,
risk_limits=self.risk_limits
)
# 4. Generate trades to move from current to target
trades = self.calculate_trades(current_positions, target_positions)
# 5. Optimize execution
scheduled_trades = self.execution.schedule(trades, market_data)
return scheduled_trades
制約付きポートフォリオ最適化
class PortfolioOptimizer:
"""
Mean-variance optimization with realistic constraints.
"""
def optimize(self,
alpha: pd.Series,
covariance: pd.DataFrame,
current_positions: pd.Series,
constraints: ConstraintSet) -> pd.Series:
"""
Solve the quadratic programming problem:
max: α'w - λ/2 * w'Σw - γ * ||w - w_0||^2
s.t.: constraints
"""
n = len(alpha)
# Objective: maximize alpha, minimize risk, minimize turnover
P = constraints.risk_aversion * covariance.values
P += constraints.turnover_aversion * np.eye(n)
q = -alpha.values + constraints.turnover_aversion * current_positions.values
# Constraints
G, h = self.build_inequality_constraints(constraints, n)
A, b = self.build_equality_constraints(constraints, n)
# Solve
solution = qp_solve(P, q, G, h, A, b)
return pd.Series(solution, index=alpha.index)
def build_inequality_constraints(self, constraints, n):
"""
Build inequality constraints: Gx <= h
- Long-only: -w <= 0
- Position limits: w <= max_position
- Sector limits: Σw_sector <= max_sector
"""
G_list = []
h_list = []
if constraints.long_only:
G_list.append(-np.eye(n))
h_list.append(np.zeros(n))
if constraints.max_position:
G_list.append(np.eye(n))
h_list.append(np.full(n, constraints.max_position))
for sector, (assets, max_weight) in constraints.sector_limits.items():
row = np.zeros(n)
row[assets] = 1.0
G_list.append(row.reshape(1, -1))
h_list.append(np.array([max_weight]))
return np.vstack(G_list), np.concatenate(h_list)
def build_equality_constraints(self, constraints, n):
"""
Build equality constraints: Ax = b
- Fully invested: Σw = 1
- Dollar neutral: Σw = 0
"""
A_list = []
b_list = []
if constraints.fully_invested:
A_list.append(np.ones((1, n)))
b_list.append(np.array([1.0]))
if constraints.dollar_neutral:
A_list.append(np.ones((1, n)))
b_list.append(np.array([0.0]))
if A_list:
return np.vstack(A_list), np.concatenate(b_list)
return None, None
思考モデル
D.E. Shaw は、定量金融に取り組む際、次のように問いかけます。
- これは検証可能な仮説か？ そうでなければ、仮説を立て直します
- 帰無仮説は何か？ 何を基準に検証するのでしょうか？
- 何がうまくいかない可能性があるか？ リターン分析より先にリスク分析を行います
- 再現可能か？ 他の人がこの結果を再現できるでしょうか？
- スケールするか？ 計算面でも経済面でも検討します
D.E. Shaw 独自の手法
- 厳密な仮説検定フレームワーク
- 多因子リスクモデル
- モジュール化された戦略構成
- 再現可能なリサーチパイプライン
- 詳細な実験トラッキング
- 段階的なポジションサイズ調整とロールアウト
- 分野横断的な人材採用
- 長期的なインフラ投資
コメント
Markdown 対応