Pembangunan Strategi Kuantitatif — Dari Hipotesis ke Pengeluaran

Membina strategi perdagangan yang menguntungkan memerlukan lebih daripada sekadar perasaan. Ia memerlukan hipotesis yang boleh diuji, pengujian balik yang ketat, dan pengoptimuman yang teliti untuk mengelakkan penyesuaian lengkung. Panduan ini membawa anda melalui pembinaan strategi kuantitatif dari prinsip pertama — metodologi yang sama yang menggerakkan algoritma di sebalik Smart Money API.

Prinsip kritikal: 95% peniaga gagal kerana mereka mengoptimumkan data dalam sampel. Strategi yang menghasilkan 200% pada data sejarah kemungkinan besar akan kehilangan wang secara langsung. Belajar untuk mengelakkan perangkap ini.

Tahap Hipotesis

Mulakan dengan Tuntutan yang Boleh Dipalsukan

Setiap strategi bermula dengan hipotesis khusus yang boleh diuji. Bukan "Bitcoin kadang-kadang naik" tetapi "Apabila kadar pembiayaan positif DAN konsensus panjang ikan paus melebihi 65%, lilin 4 jam berikutnya ditutup lebih tinggi dengan kebarangkalian 56%."

Hipotesis yang baik:

"LSR > 1.2 + Kadar pembiayaan positif = 5 lilin berikutnya menaik 60% daripada masa"
"MVRV > 1.5 (euforia on-chain) = Jangka pembalikan dalam masa 72 jam"
"Peningkatan aliran masuk pertukaran + Penurunan LSR = Kelemahan jangka pendek, kekuatan jangka panjang"

Hipotesis yang buruk:

"Harga naik apabila ikan paus optimis" (Terlalu jelas, tidak ramalan)
"Corak ini berjaya 5 kali" (Tiada ketegasan statistik)
"Beli setiap Isnin pada pukul 10 pagi UTC" (Disesuaikan dengan keanehan sejarah)

Tentukan Kelebihan Anda

Apa yang anda tahu yang pasaran tidak harga masuk? Untuk Smart Money API, ia adalah: "Perubahan konsensus ikan paus 2-4 jam sebelum reaksi runcit. Jika kita mengikuti 250 dompet teratas secara masa nyata, kita boleh mendahului pergerakan."

Kerangka Strategi

1. Syarat Kemasukan

Bilakah anda masuk? Jelas:

Python — Logik kemasukan
# Strategi: Konsensus Ikan Paus + Pertemuan Derivatif
def should_enter_long(symbol, bar):
# Syarat 1: Konsensus ikan paus > 65% panjang
whale_long_pct = get_whale_consensus(symbol)
cond_whale = whale_long_pct > 0.65
# Syarat 2: Kadar pembiayaan positif dan meningkat
fr_current = get_funding_rate(symbol)
fr_previous = get_funding_rate(symbol, offset=1)
cond_fr = (fr_current > 0) and (fr_current > fr_previous)
# Syarat 3: LSR > 1.25 (lebih panjang daripada pendek)
lsr = get_long_short_ratio(symbol)
cond_lsr = lsr > 1.25
# Syarat 4: Harga di atas MA 50 hari (konteks aliran menaik)
ma_50 = get_sma(symbol, 50)
cond_trend = bar.close > ma_50
return cond_whale and cond_fr and cond_lsr and cond_trend

2. Syarat Keluar

Bilakah anda menutup? Tentukan sasaran keuntungan dan henti:

Python — Logik keluar
def should_exit_long(entry_price, current_price, time_in_trade):
pnl_pct = (current_price - entry_price) / entry_price
# Ambil untung pada +2%
if pnl_pct > 0.02:
return True, "profit_target"
# Henti rugi pada -1%
if pnl_pct < -0.01:
return True, "stop_loss"
# Keluar berasaskan masa: tutup selepas 4 jam
if time_in_trade > timedelta(hours=4):
return True, "time_exit"
return False, None

3. Saiz Posisi

Berapa banyak anda risiko setiap dagangan? Gunakan Kriteria Kelly atau pertaruhan pecahan tetap:

Python — Saiz posisi
def calculate_position_size(account_balance, win_rate, avg_win, avg_loss):
# Kriteria Kelly: f* = (p*b - q) / b
# p = kadar kemenangan, b = nisbah menang/rugi, q = kadar kerugian
p = win_rate
q = 1 - win_rate
b = avg_win / avg_loss
kelly_fraction = (p * b - q) / b
# Gunakan 25% daripada Kelly untuk lebih konservatif (elak muflis)
position_fraction = kelly_fraction * 0.25
risk_amount = account_balance * position_fraction
return risk_amount

Membina Backtester

Enjin Backtest Berasaskan Peristiwa

Python — Rangka kerja backtest
class BacktestEngine:
def __init__(self, initial_capital=10000):
self.capital = initial_capital
self.trades = []
self.equity_curve = []
def run(diri, data, strategi):
untuk i, bar dalam enumerate(data):
# Semak syarat keluar untuk dagangan terbuka
untuk dagangan dalam diri.trades:
patut_tutup, sebab = dagangan.semak_keluar(bar.close)
jika patut_tutup:
pnl = (bar.close - dagangan.harga_masuk) * dagangan.saiz
diri.modal += pnl
diri.trades.remove(dagangan)
# Semak syarat kemasukan
jika strategi.patut_masuk(bar):
saiz = kira_saiz_kedudukan(...)
dagangan = Dagangan(harga_masuk=bar.close, saiz=saiz)
diri.trades.append(dagangan)
diri.lengkung_ekuiti.append(diri.modal)
kembalikan diri.kira_metrik()

Metrik Ujian Belakang Utama

Kadar Kemenangan: Peratusan dagangan yang ditutup dengan untung
Faktor Keuntungan: Jumlah kemenangan / Jumlah kerugian (>1.5 adalah baik)
Nisbah Sharpe: Pulangan per unit risiko (>1.0 adalah kukuh)
Penurunan Maksimum: Penurunan puncak-ke-lembah terbesar (jaga < -20%)
CAGR: Kadar pertumbuhan tahunan kompaun (metrik pulangan anda)

Mengelak Pengoptimuman Berlebihan

Perangkap Penyesuaian Berlebihan

Jika anda menyesuaikan parameter pada data sejarah sehingga pulangan 200%, anda akan kecewa dalam keadaan sebenar. Gunakan ujian luar sampel yang ketat:

Pengesahan berjalan ke hadapan: Optimumkan pada 1 tahun data, uji pada 3 bulan berikutnya. Kemudian optimumkan pada tahun 2-3, uji pada tahun 3Q1. Ulangi pada seluruh set data. Laporkan hanya keputusan luar sampel.

Kepekaan Parameter

Uji pelbagai kombinasi parameter dengan carian grid, tetapi kenakan penalti untuk kerumitan:

Python — Carian grid dengan berjalan ke hadapan
def pengoptimuman_berjalan_ke_hadapan(data, julat_param):
keputusan = []
tetingkap_latihan = 252  # 1 tahun data harian
tetingkap_ujian = 63   # 3 bulan
untuk i dalam range(0, len(data) - tetingkap_latihan - tetingkap_ujian, tetingkap_ujian):
data_latihan = data[i:i+tetingkap_latihan]
data_ujian = data[i+tetingkap_latihan:i+tetingkap_latihan+tetingkap_ujian]
# Optimumkan pada data latihan
param_terbaik = None
pulangan_terbaik = -float('inf')
untuk param dalam kombinasi_param(julat_param):
keputusan_ujian_belakang = ujian_belakang(data_latihan, param)
jika keputusan_ujian_belakang.pulangan_peratus > pulangan_terbaik:
pulangan_terbaik = keputusan_ujian_belakang.pulangan_peratus
param_terbaik = param
# Uji pada data tidak dilihat
keputusan_oos = ujian_belakang(data_ujian, param_terbaik)
keputusan.append({"is": pulangan_terbaik, "oos": keputusan_oos.pulangan_peratus})
kembalikan keputusan

Beralih ke Pengeluaran

Dagangan Kertas Dahulu

Sebelum mempertaruhkan modal sebenar, berdagang secara kertas (simulasi) selama 2-4 minggu. Strategi langsung anda akan kurang prestasi berbanding ujian belakang sebanyak 5-15% disebabkan oleh slip, kependaman, dan pelaksanaan. Jika dagangan kertas sepadan dengan ujian belakang dengan rapat, anda sudah bersedia.

Pengurusan Risiko dalam Dagangan Langsung

Dagangan langsung berbeza. Tetapkan had keras:

Had kerugian harian: Berhenti berdagang jika anda kehilangan 2% akaun hari ini
Had penurunan bulanan: Jeda jika kerugian bulan-ke-tarikh > 5%
Korelasi maksimum: Jangan ada > 3 kedudukan berkorelasi serentak
Kecairan minimum: Hanya berdagang pasangan dengan volum 24h $10M+

Integrasi dengan Smart Money API

Gunakan skor pengesahan kami sebagai pra-penapis atau pengganda pada isyarat anda:

Python — Integrasi API
import requests
def laksanakan_dengan_pengesahan(simbol, arah, kekuatan_isyarat):
# Dapatkan pengesahan Smart Money
response = requests.get(
f"https://api.smartmoneyapi.com/v1/confirm?symbol={simbol}&arah={arah}",
headers={"X-API-Key": API_KEY}
)
data = response.json()
# Gunakan pengganda saiz berdasarkan keyakinan Smart Money
jika data["keyakinan"] == TINGGI:
position_size = base_size * 1.5
elif data["keyakinan"] == SEDERHANA:
position_size = base_size * 1.0
elif data["keyakinan"] == RENDAH:
position_size = base_size * 0.5
elif data["keyakinan"] == VETO:
return "LANGKAH" # Jangan berdagang
# Laksanakan dagangan dengan saiz akhir
execute_order(symbol, direction, position_size)

Bina strategi lebih baik dengan isyarat Smart Money

Gabungkan penjejakan ikan paus, kecerdasan derivatif, dan metrik on-chain ke dalam model kuantitatif anda. Strategi yang diuji semula meningkat 5-8% apabila pengesahan Smart Money ditambahkan.

Mulakan Ujian Semula Percuma →