Awal dari segalanya

Saya sudah cukup lama berkecimpung dalam perdagangan kuantitatif. Sejujurnya, saya sering kali hanya membaca strategi yang dibagikan orang lain lalu mencoba memodifikasi parameternya. Saya tidak punya banyak kesempatan untuk benar-benar memulai strategi dari awal, terutama karena saya tidak punya ide bagus, dan jarak antara ide dan kode terasa sangat jauh.

Saya sedang senggang beberapa waktu lalu, jadi saya mulai menjelajahi B Station lagi. Saya tidak sengaja melihat siaran langsung saham Brother Z. Saya hanya menontonnya dengan santai, tetapi saya tidak menyangka itu akan memberi saya inspirasi yang tak terduga.

Ringkasan yang menakjubkan itu

Saat Saudara Z sedang berbicara tentang indikator KDJ, seorang netizen di kolom komentar menuliskan sebuah kalimat yang menurut saya sangat menarik:

Jika harga turun sedikit, hook akan turun dengan cepat, yang mungkin mengindikasikan tren bullish di masa mendatang. Jika harga turun tajam, hook akan turun perlahan, yang mungkin mengindikasikan penurunan lebih lanjut di masa mendatang. Jika harga naik sedikit, groove akan tumbuh dengan cepat, yang mungkin mengindikasikan tren bearish di masa mendatang. Jika harga naik tajam, hook akan tumbuh perlahan, yang mungkin mengindikasikan kenaikan lebih lanjut di masa mendatang.

Saya tercengang saat itu. Ringkasan ini sangat mencerahkan! Meskipun hanya satu kalimat, tampaknya menjelaskan dengan jelas perubahan aturan nilai J KDJ.

Saya berpikir, Saudara Z memang ada di pasar saham, tetapi logika ini seharusnya juga berlaku untuk mata uang kripto, bukan? Semakin saya memikirkannya, semakin masuk akal. Besarnya perubahan harga dan kecepatan reaksi indikator, gabungan kedua dimensi ini untuk menilai tren selanjutnya, terdengar sangat logis. Terlebih lagi, pasar mata uang kripto diperdagangkan 24 jam sehari, dan volatilitasnya lebih tinggi, jadi mungkin teori ini akan lebih efektif.

Saat itu, saya sedikit bersemangat dan merasa telah menemukan arah untuk dijelajahi. Namun, saya kembali khawatir, bagaimana saya bisa mengubah ide ini menjadi kode? Dulu, ketika menghadapi situasi seperti itu, saya akan memikirkannya atau mengesampingkannya dan mengerjakannya ketika ada waktu.

Memutuskan untuk mencobanya

Tapi kali ini berbeda. Saya ingat Inventor Platform punya asisten AI, jadi saya ingin mencoba apakah saya bisa langsung “menerjemahkan” ide ini ke dalam kode.

Dengan sikap ingin mencobanya, saya membuka asisten AI dari Inventor Platform, memasukkan ide kata demi kata, dan menambahkan: Ini adalah teori yang diterapkan pada saham, dan saya ingin mencobanya pada mata uang kripto.

Saya tidak menyangka AI bisa memahami secepat itu dan menghasilkan satu set kode strategi lengkap untuk saya. Saat itu, saya cukup terkejut dan berpikir, apakah AI sekarang sudah sekuat itu?

Versi pertama kode strategi:

/*backtest
start: 2024-07-18 09:40:00
end: 2025-06-30 15:00:00
period: 1h
basePeriod: 1h
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/

//@version=5
strategy("KDJ J值变化速度策略", overlay=false)

// 输入参数 - 针对加密货币市场优化
kdj_length = input.int(14, "KDJ周期", minval=1)
k_smooth = input.int(3, "K平滑", minval=1)
d_smooth = input.int(3, "D平滑", minval=1)
j_speed_period = input.int(5, "J值变化速度计算周期", minval=1)
price_change_threshold = input.float(3.0, "价格变化幅度阈值(%)-区分大小幅", minval=0.1) / 100
j_speed_threshold = input.float(12.0, "J值变化速度阈值-区分快慢", minval=0.1)
j_change_threshold = input.float(1.5, "J值变化忽略阈值-过滤噪音", minval=0.1)
price_change_ignore_threshold = input.float(0.5, "价格变化忽略阈值(%)-过滤噪音", minval=0.01) / 100

// 加密货币风控参数
max_consecutive_trades = input.int(5, "最大连续交易次数", minval=1)
min_bars_between_signals = input.int(3, "信号间最小间隔K线数", minval=1)
enable_stop_loss = input.bool(true, "启用止损")
stop_loss_pct = input.float(5.0, "止损百分比(%)", minval=0.5) / 100

// 计算KDJ指标
highest_high = ta.highest(high, kdj_length)
lowest_low = ta.lowest(low, kdj_length)
rsv = (close - lowest_low) / (highest_high - lowest_low) * 100

k = ta.sma(rsv, k_smooth)
d = ta.sma(k, d_smooth)
j = 3 * k - 2 * d

// 计算J值连续变化速度
// 统计连续上涨或下跌的累计变化量和持续时间
var float j_cumulative_change = 0.0
var int j_consecutive_bars = 0
var int j_direction = 0  // 1为上涨，-1为下跌，0为初始

j_current_change = j - j[1]
// 只有变化幅度超过阈值才认为有方向性
j_current_direction = math.abs(j_current_change) > j_change_threshold ? 
                     (j_current_change > 0 ? 1 : -1) : 0

// 检测J值方向是否改变
if j_current_direction != j_direction and j_current_direction != 0
    // 方向改变，重新开始统计
    j_cumulative_change := math.abs(j_current_change)
    j_consecutive_bars := 1
    j_direction := j_current_direction
else if j_current_direction == j_direction and j_current_direction != 0
    // 方向相同，累计变化
    j_cumulative_change += math.abs(j_current_change)
    j_consecutive_bars += 1
else if j_current_direction == 0
    // 变化太小忽略，但时间继续累计
    j_consecutive_bars += 1

// J值变化速度 = 累计变化量 / 持续时间
j_speed = j_consecutive_bars > 0 ? j_cumulative_change / j_consecutive_bars : 0

// 计算价格连续变化幅度
// 统计连续上涨或下跌的累计变化量和持续时间
var float price_cumulative_change = 0.0
var int price_consecutive_bars = 0
var int price_direction = 0  // 1为上涨，-1为下跌，0为初始

price_current_change = (close - close[1]) / close[1]
// 只有变化幅度超过阈值才认为有方向性
price_current_direction = math.abs(price_current_change) > price_change_ignore_threshold ? 
                         (price_current_change > 0 ? 1 : -1) : 0

// 检测价格方向是否改变
if price_current_direction != price_direction and price_current_direction != 0
    // 方向改变，重新开始统计
    price_cumulative_change := math.abs(price_current_change)
    price_consecutive_bars := 1
    price_direction := price_current_direction
else if price_current_direction == price_direction and price_current_direction != 0
    // 方向相同，累计变化
    price_cumulative_change += math.abs(price_current_change)
    price_consecutive_bars += 1
else if price_current_direction == 0
    // 变化太小忽略，但时间继续累计
    price_consecutive_bars += 1

// 价格变化幅度 = 累计变化量
price_change = price_cumulative_change

// 判断价格变化类型
is_small_change = price_change < price_change_threshold
is_large_change = price_change >= price_change_threshold

// 判断价格方向（基于当前连续变化方向）
is_price_up = price_direction == 1
is_price_down = price_direction == -1

// 判断J值变化速度
is_j_fast = j_speed > j_speed_threshold
is_j_slow = j_speed <= j_speed_threshold  

// 交易控制变量
var float entry_price = 0.0

// 策略信号逻辑
// 1. 小幅下跌钩掉的快，可能后期看涨
signal_small_down_fast_j = is_small_change and is_price_down and is_j_fast 

// 2. 大幅下跌勾下的慢，后期还要再跌
signal_large_down_slow_j = is_large_change and is_price_down and is_j_slow 

// 3. 小幅上涨沟长得快，可能后期看跌
signal_small_up_fast_j = is_small_change and is_price_up and is_j_fast 

// 4. 大幅上涨勾长得慢，后期可能还要再涨
signal_large_up_slow_j = is_large_change and is_price_up and is_j_slow 

// 交易信号
long_signal = (signal_small_down_fast_j or signal_large_up_slow_j) 
short_signal = (signal_small_up_fast_j or signal_large_down_slow_j) 

// 执行交易
if long_signal and strategy.position_size == 0
    strategy.entry("Long", strategy.long, comment="多头信号开仓")
    entry_price := close

    
if short_signal and strategy.position_size == 0
    strategy.entry("Short", strategy.short, comment="空头信号开仓")
    entry_price := close


// 平仓条件
// 1. 信号反转平仓
if strategy.position_size > 0 and short_signal
    strategy.close("Long", comment="信号反转平多仓")

    
if strategy.position_size < 0 and long_signal
    strategy.close("Short", comment="信号反转平空仓")


// 2. 止损平仓
if enable_stop_loss
    if strategy.position_size > 0 and close <= entry_price * (1 - stop_loss_pct)
        strategy.close("Long", comment="止损平多仓")

        
    if strategy.position_size < 0 and close >= entry_price * (1 + stop_loss_pct)
        strategy.close("Short", comment="止损平空仓")


// 绘制指标
plot(j, "J值", color=color.blue, linewidth=2)
hline(80, "超买线", color=color.red, linestyle=hline.style_dashed)
hline(20, "超卖线", color=color.green, linestyle=hline.style_dashed)
hline(50, "中线", color=color.gray, linestyle=hline.style_dotted)

// 绘制信号标记
plotshape(signal_small_down_fast_j, title="小跌快勾-看涨", location=location.belowbar, color=color.lime, style=shape.triangleup, size=size.small,overlay=true)
plotshape(signal_large_down_slow_j, title="大跌慢勾-看跌", location=location.belowbar, color=color.red, style=shape.triangledown, size=size.small,overlay=true)
plotshape(signal_small_up_fast_j, title="小涨快勾-看跌", location=location.abovebar, color=color.red, style=shape.triangledown, size=size.small,overlay=true)
plotshape(signal_large_up_slow_j, title="大涨慢勾-看涨", location=location.abovebar, color=color.lime, style=shape.triangleup, size=size.small,overlay=true)

Kegembiraan dan kekecewaan pertama kali

Setelah mendapatkan kodenya, hal pertama yang saya lakukan adalah memeriksa apakah kode tersebut bisa dijalankan. Editor Inventor Platform menyatakan tidak ada kesalahan sintaksis, dan saya merasa lega.

Kemudian tibalah momen paling seru - uji coba online. Di halaman Inventor AI Assistant, Anda dapat melakukan uji coba online secara real-time di pojok kanan bawah halaman yang dihasilkan. Pilih mata uang uji coba BTC, atur rentang waktunya, lalu klik tombol uji coba online.

Setelah hasilnya keluar, saya merasa agak campur aduk. Kodenya memang berjalan, dan logikanya tampak benar, tetapi hasil backtest-nya kurang ideal. Meskipun ada kalanya saya mendapat untung, tingkat kemenangan keseluruhannya tidak tinggi, dan saya sering mengalami kerugian beruntun.

Rasanya seperti pesawat yang seharusnya bisa terbang secara teori sudah dibuat, tetapi ternyata tidak bisa terbang. Saya merasa sedikit kecewa, tetapi saya tidak mau menyerah.

Jatuh ke dalam pikiran

Jika teorinya masuk akal dan kodenya berfungsi, apa masalahnya?

Saya mulai mempelajari logika kode dengan saksama. Saya menemukan bahwa kode yang ditulis oleh AI terutama menilai “cepat” dan “lambat” dengan menghitung kecepatan perubahan nilai J:

j_speed = j_cumulative_change / j_consecutive_bars
is_j_fast = j_speed > j_speed_threshold
is_j_slow = j_speed <= j_speed_threshold

Sekilas, tampaknya tidak ada yang salah, tetapi saya selalu merasa ada sesuatu yang salah.

Setelah memikirkannya, saya tiba-tiba menyadari suatu masalah: perhitungan ini hanya melihat kecepatan perubahan pada saat tertentu, tetapi tidak memperhitungkan perubahanKontinuitas。

Misalnya, nilai J mungkin berubah cepat pada hari tertentu, tetapi itu hanya sesaat dan kembali normal keesokan harinya. Dalam hal ini, menilai berdasarkan kecepatan satu titik mungkin tidak akurat.

Teori aslinya menyatakan “melepas dengan cepat” dan “melepas dengan lambat”. Kata “cepat” dan “lambat” seharusnya merujuk pada proses yang berkelanjutan, bukan pada kondisi tertentu.

Menemukan terobosan

Setelah menyadari masalah ini, saya merasa sedikit bersemangat lagi. Saya merasa telah menemukan kuncinya, tetapi saya tidak tahu cara mengubah kodenya.

Saat itu, saya teringat beberapa komentar yang pernah saya lihat sebelumnya, seseorang menyebutkan bahwa kita harus memperhatikan kontinuitas perubahan indikator. Ya, kontinuitas! Inilah yang saya pikirkan.

Saya kembali ke asisten AI dan kali ini saya mengajukan permintaan yang jelas: kita harus menyoroti kontinuitas perubahan nilai J. Kita tidak bisa hanya melihat kecepatan perubahan satu titik, tetapi harus melihat tren perubahan selama beberapa hari berturut-turut.

Solusi yang diberikan AI kali ini sungguh membuka mata. Ia mendesain ulang seluruh logika analisis nilai J:

1. Tidak hanya mencatat arah perubahan saat ini, tetapi juga melacak jumlah hari perubahan berturut-turut
2. Tren hanya dianggap valid jika tren berubah ke arah yang sama selama beberapa hari berturut-turut.
3. Setelah memastikan kesinambungan, kita kemudian dapat menilai kecepatan perubahan.

Versi perbaikan kedua dari kode strategi:

/*backtest
start: 2024-07-18 09:40:00
end: 2025-06-30 15:00:00
period: 1h
basePeriod: 1h
exchanges: [{"eid":"Binance","currency":"BTC_USDT"}]
*/

//@version=5
strategy("KDJ J值连续性变化策略", overlay=false)

// 输入参数
kdj_length = input.int(9, "KDJ周期", minval=1)
k_smooth = input.int(3, "K平滑", minval=1)
d_smooth = input.int(3, "D平滑", minval=1)
j_speed_period = input.int(3, "J值变化速度计算周期", minval=1)
price_change_threshold = input.float(1.5, "价格变化幅度阈值(%)-区分大小幅", minval=0.1) / 100
j_fast_threshold = input.float(15.0, "J值快速变化阈值", minval=1.0)
j_slow_threshold = input.float(5.0, "J值慢速变化阈值", minval=0.1)
j_change_threshold = input.float(1.0, "J值变化忽略阈值-过滤噪音", minval=0.1)
price_change_ignore_threshold = input.float(0.2, "价格变化忽略阈值(%)-过滤噪音", minval=0.01) / 100
min_consecutive_bars = input.int(3, "最小连续K线数", minval=2)

// 风控参数
max_consecutive_trades = input.int(3, "最大连续交易次数", minval=1)
min_bars_between_signals = input.int(5, "信号间最小间隔K线数", minval=1)
enable_stop_loss = input.bool(true, "启用止损")
stop_loss_pct = input.float(3.0, "止损百分比(%)", minval=0.5) / 100

// 计算KDJ指标
highest_high = ta.highest(high, kdj_length)
lowest_low = ta.lowest(low, kdj_length)
rsv = (close - lowest_low) / (highest_high - lowest_low) * 100

k = ta.sma(rsv, k_smooth)
d = ta.sma(k, d_smooth)
j = 3 * k - 2 * d

// 改进的J值连续性变化分析
var float j_cumulative_change = 0.0  // 保持方向性的累计变化（正负数）
var int j_consecutive_bars = 0
var int j_direction = 0  // 1为连续上涨，-1为连续下跌，0为无明确方向
var float j_start_value = 0.0

j_current_change = j - j[1]
// 只有变化幅度超过阈值才认为有方向性
j_current_direction = math.abs(j_current_change) > j_change_threshold ? 
                     (j_current_change > 0 ? 1 : -1) : 0

// 重新设计J值连续性检测逻辑
if j_current_direction != 0
    if j_current_direction == j_direction
        // 方向相同，继续累计（保持正负号）
        j_cumulative_change += j_current_change
        j_consecutive_bars += 1
    else
        // 方向改变，重新开始统计
        j_cumulative_change := j_current_change
        j_consecutive_bars := 1
        j_direction := j_current_direction
        j_start_value := j[1]
else
    // 变化很小，视为横盘，重置连续性
    if j_consecutive_bars > 0
        j_consecutive_bars += 1
    else
        j_cumulative_change := 0.0
        j_consecutive_bars := 0
        j_direction := 0

// 计算J值连续性指标（保持方向性）
j_total_change = j - j_start_value  // 从起始点到当前的总变化（带正负号）
j_avg_speed = j_consecutive_bars > 0 ? j_cumulative_change / j_consecutive_bars : 0  // 平均变化速度（带正负号）
j_abs_avg_speed = math.abs(j_avg_speed)  // 变化速度的绝对值

// 新的J值变化判断逻辑
is_j_continuous_up = j_direction == 1 and j_consecutive_bars >= min_consecutive_bars
is_j_continuous_down = j_direction == -1 and j_consecutive_bars >= min_consecutive_bars

// 基于连续性和变化幅度的快慢判断
is_j_fast_up = is_j_continuous_up and j_abs_avg_speed > j_fast_threshold
is_j_slow_up = is_j_continuous_up and j_abs_avg_speed <= j_slow_threshold and j_abs_avg_speed > 0
is_j_fast_down = is_j_continuous_down and j_abs_avg_speed > j_fast_threshold  
is_j_slow_down = is_j_continuous_down and j_abs_avg_speed <= j_slow_threshold and j_abs_avg_speed > 0

// 计算价格连续变化幅度（保持原有逻辑）
var float price_cumulative_change = 0.0
var int price_consecutive_bars = 0
var int price_direction = 0

price_current_change = (close - close[1]) / close[1]
price_current_direction = math.abs(price_current_change) > price_change_ignore_threshold ? 
                         (price_current_change > 0 ? 1 : -1) : 0

if price_current_direction != price_direction and price_current_direction != 0
    price_cumulative_change := math.abs(price_current_change)
    price_consecutive_bars := 1
    price_direction := price_current_direction
else if price_current_direction == price_direction and price_current_direction != 0
    price_cumulative_change += math.abs(price_current_change)
    price_consecutive_bars += 1
else if price_current_direction == 0
    price_consecutive_bars += 1

price_change = price_cumulative_change

// 判断价格变化类型
is_small_change = price_change < price_change_threshold
is_large_change = price_change >= price_change_threshold
is_price_up = price_direction == 1
is_price_down = price_direction == -1

// 交易控制变量
var float entry_price = 0.0

// 重新设计策略信号逻辑，强调J值的连续性
// 1. 小幅下跌 + J值连续快速下钩 = 看涨（下跌惯性减弱，J值快速回落）
signal_small_down_fast_j_down = is_small_change and is_price_down and is_j_fast_down

// 2. 大幅下跌 + J值连续慢速下钩 = 看跌（下跌惯性仍在，J值缓慢下行）
signal_large_down_slow_j_down = is_large_change and is_price_down and is_j_slow_down

// 3. 小幅上涨 + J值连续快速上钩 = 看跌（上涨惯性减弱，J值快速回落）
signal_small_up_fast_j_up = is_small_change and is_price_up and is_j_fast_up

// 4. 大幅上涨 + J值连续慢速上钩 = 看涨（上涨惯性仍在，J值持续上行）
signal_large_up_slow_j_up = is_large_change and is_price_up and is_j_slow_up

// 交易信号
long_signal = (signal_small_down_fast_j_down or signal_large_up_slow_j_up) 
short_signal = (signal_small_up_fast_j_up or signal_large_down_slow_j_down) 

// 执行交易
if long_signal and strategy.position_size == 0
    strategy.entry("Long", strategy.long, comment="多头信号开仓")
    entry_price := close
    
if short_signal and strategy.position_size == 0
    strategy.entry("Short", strategy.short, comment="空头信号开仓")
    entry_price := close

// 平仓条件
if strategy.position_size > 0 and short_signal
    strategy.close("Long", comment="信号反转平多仓")
    
if strategy.position_size < 0 and long_signal
    strategy.close("Short", comment="信号反转平空仓")

// 止损平仓
if enable_stop_loss
    if strategy.position_size > 0 and close <= entry_price * (1 - stop_loss_pct)
        strategy.close("Long", comment="止损平多仓")
        
    if strategy.position_size < 0 and close >= entry_price * (1 + stop_loss_pct)
        strategy.close("Short", comment="止损平空仓")

// 绘制指标
plot(j, "J值", color=color.blue, linewidth=2)
hline(80, "超买线", color=color.red, linestyle=hline.style_dashed)
hline(20, "超卖线", color=color.green, linestyle=hline.style_dashed)
hline(50, "中线", color=color.gray, linestyle=hline.style_dotted)

// 在下方子图显示连续性指标
plot(j_consecutive_bars, "连续K线数", color=color.orange)
plot(j_avg_speed, "平均变化速度(带方向)", color=color.purple)
plot(j_abs_avg_speed, "平均变化速度(绝对值)", color=color.yellow)

// 绘制信号标记
plotshape(signal_small_down_fast_j_down, title="小跌+J快速下钩-看涨", location=location.belowbar, color=color.lime, style=shape.triangleup, size=size.small, overlay=true)
plotshape(signal_large_down_slow_j_down, title="大跌+J慢速下钩-看跌", location=location.belowbar, color=color.red, style=shape.triangledown, size=size.small, overlay=true)
plotshape(signal_small_up_fast_j_up, title="小涨+J快速上钩-看跌", location=location.abovebar, color=color.red, style=shape.triangledown, size=size.small, overlay=true)
plotshape(signal_large_up_slow_j_up, title="大涨+J慢速上钩-看涨", location=location.abovebar, color=color.lime, style=shape.triangleup, size=size.small, overlay=true)

// 背景色显示J值连续性状态
bgcolor(is_j_continuous_up ? color.new(color.green, 95) : is_j_continuous_down ? color.new(color.red, 95) : na, title="J值连续性背景")

Melihat peningkatan ini, saya merasa senang karena “inilah rasanya”. Kini, perubahan nilai J bukan lagi sebuah titik yang terisolasi, melainkan sebuah tren berkelanjutan.

Kejutan dari backtest kedua

Setelah mendapatkan kode baru, saya tidak sabar untuk melakukan uji ulang lagi.

Saya agak terkejut dengan hasilnya kali ini. Meskipun belum bisa dikatakan strategi yang sempurna, jelas jauh lebih baik daripada versi pertama:

• Terdapat lebih sedikit sinyal palsu karena persyaratan kontinuitas menyaring banyak gangguan.
• Tingkat kemenangan telah meningkat secara signifikan
• Logika strategi lebih jelas

Melihat kurva profit pada laporan backtest, saya merasa sangat puas. Meskipun ini bukan strategi yang luar biasa, strategi ini berawal dari sebuah ide dan dieksplorasi selangkah demi selangkah.

Pengalaman penggunaan alat

Eksplorasi ini memberi saya pemahaman baru tentang asisten AI dan platform kuantitatif.

Nilai asisten AI:

Dulu saya berpikir AI hanyalah alat bantu kecerdasan buatan yang lemah, tetapi kali ini saya menemukan bahwa AI sangat berguna dalam perdagangan kuantitatif. Nilai terbesarnya bukanlah menggantikan pemikiran manusia, melainkan memperpendek jarak dari ide ke kode.

1. Kemampuan pemahaman yang kuat:Saya baru saja menjelaskan sebuah ide dalam bahasa yang sangat sederhana, dan itu dapat dipahami secara akurat dan diubah menjadi logika strategis yang lengkap
2. Kecepatan iterasi yang cepat:Ketika saya membuat permintaan perbaikan, ia dapat dengan cepat menemukan masalah dan memberikan solusi
3. Kualitas kode yang baik：Kode yang dihasilkan tidak hanya dapat dieksekusi, tetapi juga memiliki struktur yang jelas dan komentar yang terperinci

Kenyamanan platform kuantitatif: Saya juga terkesan dengan fitur uji coba balik (backtesting) platform Inventor. Dulu, jika Anda ingin menguji coba balik suatu strategi, Anda harus mencari data historis, menulis kerangka kerja pengujian balik (backtesting framework), dan menangani berbagai detail teknis. Sekarang Anda hanya perlu menempelkan kode, mengatur parameter, dan Anda dapat langsung melihat hasilnya.

Umpan balik instan ini membuat seluruh proses eksplorasi menjadi sangat lancar, dan ide, kode, verifikasi, dan perbaikan membentuk siklus yang sangat cepat.

Beberapa refleksi

Tentu saja, eksplorasi ini juga membuat saya memikirkan beberapa pertanyaan:

Keterbatasan AI: Meskipun AI telah banyak membantu, pada akhirnya AI tidak mahakuasa. AI tidak dapat menemukan sendiri masalah pada versi pertama kode, dan masih membutuhkan manusia untuk menganalisis dan menilai. Lebih lanjut, solusi yang diberikan AI mungkin bukan yang terbaik, dan perlu disesuaikan dengan situasi aktual.

Keterbatasan dari strategi itu sendiri: Meskipun strategi ini berkinerja baik dalam uji coba ulang, strategi ini bukanlah solusi sempurna. Strategi ini umumnya berkinerja baik di pasar yang volatil, dan parameternya perlu disesuaikan dengan mata uang yang berbeda.

Yang terpenting, meskipun suatu strategi berkinerja baik berdasarkan data historis, tidak dapat dipastikan bahwa strategi tersebut akan efektif di masa mendatang. Pasar terus berubah, dan strategi perlu terus disesuaikan.

Bonus yang tak terduga

Selain strategi itu sendiri, eksplorasi ini juga menghasilkan beberapa keuntungan tak terduga:

Pemahaman tentang perdagangan kuantitatif telah berubah: Dulu saya berpikir bahwa ambang batas untuk perdagangan kuantitatif sangat tinggi, membutuhkan keterampilan pemrograman dan dasar matematika yang kuat. Pengalaman ini membuat saya merasa bahwa ide dan logika lebih penting. Dengan perangkat yang baik, ambang batas teknis tidak setinggi yang dibayangkan.

Perubahan sikap terhadap pembelajaran: Dulu, ketika menemukan ide-ide menarik, saya selalu berpikir, “Nanti saya coba kalau ada waktu,” tetapi seringkali sia-sia. Pengalaman ini menyadarkan saya bahwa perangkat yang ada saat ini memudahkan kita untuk “mencoba”, kuncinya adalah keberanian untuk bertindak.

Perspektif terhadap kegagalan telah berubah: Ketika versi pertama strategi tersebut tidak berhasil, saya tidak langsung menyerah, melainkan menganalisis masalahnya. Proses ini menyadarkan saya bahwa kegagalan seringkali bukanlah akhir, melainkan petunjuk untuk menemukan arah yang benar.

Rencana selanjutnya

Strategi ini masih ada di basis kode saya dan saya menggunakannya sesekali. Meskipun bukan strategi yang sempurna, saya cukup puas dengan hasil eksplorasinya.

Yang lebih penting, pengalaman ini memberi saya kepercayaan diri. Ternyata jarak antara ide dan strategi tidak sejauh yang saya bayangkan.

Selanjutnya saya ingin melanjutkan eksplorasi ini:

• Perhatikan lebih lanjut beberapa teori dan ide perdagangan yang menarik
• Cobalah menerapkan beberapa konsep dari bidang lain ke dalam perdagangan
• Terus memanfaatkan AI dan platform kuantitatif untuk memvalidasi ide dengan cepat

Saran untuk orang lain

Jika Anda juga tertarik dengan perdagangan kuantitatif, saran saya adalah:

1. Jangan terintimidasi oleh hambatan teknis:Alat yang ada saat ini sudah sangat powerful, yang penting ada ide dan eksekusi
2. Mulailah dari yang Kecil:Tidak perlu mengejar strategi yang sempurna, mulailah menjelajah dengan ide-ide sederhana
3. Berani untuk mencoba dan gagal: Kegagalan pertama kali itu wajar. Kuncinya adalah menganalisis masalah dan melakukan perbaikan berkelanjutan.
4. Pertahankan sikap belajarPerhatikan lebih lanjut berbagai sudut pandang dan teori. Inspirasi seringkali datang dari tempat yang tak terduga.

Kesimpulan

Kalau dipikir-pikir kembali, titik awal eksplorasi ini hanyalah komentar tentang Bilibili, tetapi ini memungkinkan saya mengalami proses pengembangan strategi kuantitatif yang lengkap.

Di era di mana pengetahuan dan perangkat ada di ujung jari kita, mungkin kita memang kurang berani. Baik Anda seorang pemula kuantitatif maupun pedagang berpengalaman, Anda dapat mencoba memulai dengan ide sederhana dan melihat ke mana arahnya.

Strategi menarik berikutnya mungkin tersembunyi dalam komentar yang baru saja Anda baca.

Penafian: Ini hanyalah berbagi pengalaman eksplorasi pribadi, bukan nasihat investasi. Perdagangan berisiko, harap buat keputusan dengan hati-hati.