Permulaan segalanya

Saya telah melakukan perdagangan kuantitatif untuk seketika. Sejujurnya, kebanyakan masa saya hanya membaca strategi yang dikongsi oleh orang lain dan kemudian cuba mengubah suai parameter. Saya tidak mempunyai banyak peluang untuk benar-benar memulakan strategi dari awal, terutamanya kerana saya tidak mempunyai idea yang bagus, dan jarak dari idea ke kod terasa agak jauh.

Saya bebas beberapa ketika dahulu, jadi saya mula melayari stesen B semula. Saya secara tidak sengaja melihat siaran langsung saham Abang Z. Saya hanya menontonnya secara santai, tetapi saya tidak menyangka ia memberi saya inspirasi yang tidak dijangka.

Ringkasan yang menakjubkan itu

Apabila Saudara Z bercakap tentang penunjuk KDJ, seorang netizen di ruang komen menyiarkan ayat yang saya dapati sangat menarik:

“Sekiranya harga turun sedikit, mata kail jatuh dengan cepat, yang mungkin menunjukkan arah aliran menaik pada masa hadapan. Jika harga jatuh secara mendadak, mata kail jatuh perlahan-lahan, yang mungkin menunjukkan penurunan selanjutnya pada masa hadapan. Jika harga naik sedikit, alur tumbuh dengan cepat, yang mungkin menunjukkan arah aliran menurun pada masa hadapan. Jika harga meningkat secara mendadak, mata kail tumbuh perlahan, yang mungkin menunjukkan kenaikan selanjutnya pada masa hadapan.”

Saya terkedu ketika itu. Ringkasan ini sangat bernas! Walaupun ia hanya satu ayat, ia seolah-olah menerangkan dengan jelas peraturan perubahan nilai J KDJ.

Saya terfikir sendiri, Abang Z berada dalam pasaran saham, tetapi logik ini juga harus digunakan untuk mata wang kripto, bukan? Semakin saya memikirkannya, semakin masuk akal. Magnitud perubahan harga dan kelajuan tindak balas penunjuk, kedua-dua dimensi ini digabungkan untuk menilai arah aliran berikutnya, terdengar sangat logik. Selain itu, pasaran mata wang kripto didagangkan 24 jam sehari, dan turun naik adalah lebih besar, jadi mungkin teori ini akan berprestasi lebih baik.

Pada masa itu, saya sedikit teruja, dan merasakan bahawa saya telah menemui hala tuju untuk diterokai. Tetapi kemudian saya bimbang sekali lagi, bagaimana saya boleh menukar idea ini menjadi kod? Dahulu, apabila saya menghadapi situasi sebegini, saya akan memikirkannya atau mengetepikan dan melakukannya apabila ada masa.

Memutuskan untuk mencubanya

Tetapi kali ini berbeza. Saya teringat bahawa Platform Pencipta mempunyai pembantu AI, jadi saya ingin mencuba untuk melihat sama ada saya boleh terus “menterjemahkan” idea ini ke dalam kod.

Dengan sikap mencuba-cuba, saya membuka pembantu AI Platform Pencipta, memasukkan idea secara verbatim, dan menambah: Ini adalah teori yang digunakan untuk saham, dan saya ingin mencubanya pada mata wang kripto.

Saya tidak menjangkakan AI memahami dengan begitu cepat dan pantas menjana set lengkap kod strategi untuk saya. Pada ketika itu, saya agak terkejut dan terfikir, adakah AI begitu berkuasa sekarang?

Versi pertama kod 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)

Keterujaan dan kekecewaan kali pertama

Selepas mendapat kod, perkara pertama yang saya lakukan ialah menyemak sama ada ia boleh dijalankan. Editor Platform Inventor menunjukkan bahawa tiada ralat sintaks, dan saya berasa lega.

Kemudian tibalah saat yang paling menarik - ujian belakang dalam talian. Pada halaman Penolong AI Pencipta, anda boleh melakukan ujian balik dalam talian masa nyata di sudut kanan bawah halaman yang dijana. Pilih mata wang ujian belakang BTC, tetapkan julat masa dan klik butang ujian belakang dalam talian.

Selepas keputusan keluar, saya berasa agak bercampur-campur. Kod itu berjalan, dan logiknya kelihatan betul, tetapi hasil ujian belakang tidak sesuai. Walaupun ada kalanya saya mendapat keuntungan, kadar kemenangan keseluruhan tidaklah tinggi, dan saya sering mengalami kerugian berturut-turut.

Rasanya seperti pesawat yang sepatutnya boleh terbang secara teori telah dibina tetapi tidak boleh terbang selepas semua. Saya berasa sedikit kecewa, tetapi saya tidak mahu berputus asa.

Jatuh dalam pemikiran

Jika teori itu masuk akal dan kod itu berfungsi, apakah masalahnya?

Saya mula mengkaji logik kod itu dengan teliti. Saya mendapati bahawa kod yang ditulis oleh AI terutamanya menilai “cepat” dan “lambat” dengan mengira kelajuan 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

Sekali pandang macam tak salah pun tapi selalu rasa macam ada yang tak kena.

Selepas memikirkannya, saya tiba-tiba menyedari masalah: pengiraan ini hanya melihat kelajuan perubahan pada masa tertentu, tetapi tidak mengambil kira perubahanKesinambungan。

Sebagai contoh, nilai J mungkin berubah dengan cepat pada hari tertentu, tetapi ia hanya kilat dalam kuali dan kembali normal pada hari berikutnya. Dalam kes ini, menilai dengan kelajuan satu titik mungkin tidak tepat.

Teori asal mengatakan “menyambung dengan cepat” dan “menyambung perlahan-lahan”. “cepat” dan “lambat” harus merujuk kepada proses yang berterusan dan bukannya keadaan pada titik tertentu.

Mencari kejayaan

Selepas menyedari masalah ini, saya kembali sedikit teruja. Saya rasa seperti saya telah menemui kunci, tetapi saya tidak tahu bagaimana untuk menukar kod itu.

Pada masa ini, saya teringat beberapa komen yang saya lihat sebelum ini, seseorang menyebut bahawa kita harus memberi perhatian kepada kesinambungan perubahan penunjuk. Ya, kesinambungan! Inilah yang saya fikirkan.

Saya kembali kepada pembantu AI dan kali ini saya membuat permintaan yang jelas: kita mesti menyerlahkan kesinambungan perubahan dalam nilai J. Kita tidak boleh hanya melihat pada kelajuan perubahan satu titik, tetapi mesti melihat arah aliran perubahan selama beberapa hari berturut-turut.

Penyelesaian yang disediakan oleh AI kali ini membuka mata. Ia mereka bentuk semula keseluruhan logik analisis nilai J:

1. Bukan sahaja merekodkan arah perubahan semasa, tetapi juga menjejaki bilangan hari perubahan berturut-turut
2. Hanya apabila arah aliran berubah ke arah yang sama selama beberapa hari berturut-turut, ia dianggap sebagai aliran yang sah.
3. Selepas mengesahkan kesinambungan, kita boleh menilai kelajuan perubahan.

Versi kedua yang dipertingkatkan bagi kod 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 berasa teruja bahawa “ini adalah perasaan”. Kini perubahan nilai J bukan lagi titik terpencil, tetapi trend berterusan.

Kejutan ujian belakang kedua

Selepas mendapat kod baharu, saya tidak sabar untuk melakukan ujian belakang yang lain.

Saya agak terkejut dengan keputusan kali ini. Walaupun ia tidak boleh dikatakan sebagai strategi yang sempurna, ia jelas jauh lebih baik daripada versi pertama:

• Terdapat lebih sedikit isyarat palsu kerana keperluan untuk kesinambungan menapis banyak bunyi.
• Kadar kemenangan telah meningkat dengan ketara
• Logik strategi lebih jelas

Melihat keluk keuntungan pada laporan backtest, saya merasakan pencapaian yang kuat. Walaupun ia bukan strategi yang menghancurkan bumi, ia bermula dengan idea dan diterokai langkah demi langkah.

Pengalaman penggunaan alat

Penerokaan ini memberi saya pemahaman baharu tentang pembantu AI dan platform kuantitatif.

Nilai pembantu AI:

Saya pernah berfikir bahawa AI hanyalah alat bantu kecerdasan yang lemah, tetapi kali ini saya mendapati bahawa ia benar-benar berguna dalam perdagangan kuantitatif. Nilai terbesar bukanlah untuk menggantikan pemikiran manusia, tetapi untuk memendekkan jarak dari idea ke kod.

1. Keupayaan pemahaman yang kuat: Saya baru sahaja menerangkan idea dalam bahasa yang sangat mudah, dan ia boleh difahami dengan tepat dan diubah menjadi logik strategik yang lengkap
2. Kelajuan lelaran yang cepat: Apabila saya membuat permintaan untuk penambahbaikan, ia dapat mengesan masalah dengan cepat dan memberikan penyelesaian
3. Kualiti kod yang baik：Kod yang dihasilkan bukan sahaja boleh dilaksanakan, tetapi juga mempunyai struktur yang jelas dan ulasan terperinci

Kemudahan platform kuantitatif: Saya juga kagum dengan fungsi ujian belakang platform Inventor. Pada masa lalu, jika anda ingin menguji balik strategi, anda perlu mencari data sejarah, menulis rangka kerja ujian belakang dan menangani pelbagai butiran teknikal. Kini anda hanya perlu menampal kod, tetapkan parameter dan anda boleh melihat hasilnya dengan serta-merta.

Maklum balas segera ini menjadikan keseluruhan proses penerokaan sangat lancar, dan idea, kod, pengesahan dan penambahbaikan membentuk kitaran yang sangat pantas.

Beberapa renungan

Sudah tentu, penerokaan ini juga membuatkan saya memikirkan beberapa soalan:

Had AI: Walaupun AI telah banyak membantu, ia bukanlah yang maha berkuasa. AI tidak dapat mencari masalah versi pertama kod dengan sendirinya, dan masih memerlukan orang untuk menganalisis dan menilai. Selain itu, penyelesaian yang diberikan oleh AI mungkin bukan yang terbaik, dan ia perlu diselaraskan mengikut situasi sebenar.

Had strategi itu sendiri: Walaupun strategi ini menunjukkan prestasi yang baik dalam ujian belakang, ia bukanlah ubat mujarab. Ia secara amnya berprestasi baik dalam pasaran yang tidak menentu, dan parameter perlu diselaraskan mengikut mata wang yang berbeza.

Perkara yang paling penting ialah hanya kerana strategi berprestasi baik dalam data sejarah, ia tidak boleh diandaikan bahawa ia akan berkesan pada masa hadapan. Pasaran sedang berubah, dan strategi perlu sentiasa diselaraskan.

Bonus yang tidak dijangka

Sebagai tambahan kepada strategi itu sendiri, penerokaan ini juga menghasilkan beberapa keuntungan yang tidak dijangka:

Pemahaman perdagangan kuantitatif telah berubah: Saya pernah berfikir bahawa ambang untuk perdagangan kuantitatif adalah sangat tinggi, memerlukan kemahiran pengaturcaraan yang kukuh dan asas matematik. Pengalaman ini membuatkan saya rasa idea dan logik lebih penting. Dengan alatan yang baik, ambang teknikal tidak setinggi yang dibayangkan.

Perubahan sikap terhadap pembelajaran: Dahulu, apabila saya menemui idea yang menarik, saya selalu berfikir, “Saya akan mencubanya apabila saya mempunyai masa”, tetapi ia sering berakhir dengan sia-sia. Pengalaman ini menyedarkan saya bahawa alat semasa telah memudahkan untuk “mencuba”, kuncinya ialah mempunyai keberanian untuk bertindak.

Perspektif kegagalan telah berubah: Apabila versi pertama strategi tidak berfungsi dengan baik, saya tidak berputus asa serta-merta, tetapi menganalisis masalah itu. Proses ini menyedarkan saya bahawa kegagalan selalunya bukan penamat, tetapi petunjuk untuk mencari arah yang betul.

Rancangan seterusnya

Strategi ini masih dalam pangkalan kod saya dan saya menggunakannya sekali-sekala. Walaupun ia bukan strategi yang sempurna, saya cukup berpuas hati dengannya hasil penerokaan.

Lebih penting lagi, pengalaman ini memberi saya keyakinan. Ternyata jarak dari idea ke strategi tidaklah sejauh yang saya bayangkan.

Seterusnya saya ingin meneruskan penerokaan ini:

• Beri perhatian lebih kepada beberapa teori dan idea perdagangan yang menarik
• Cuba gunakan beberapa konsep dari bidang lain untuk berdagang
• Teruskan memanfaatkan AI dan platform kuantitatif untuk mengesahkan idea dengan cepat

Nasihat untuk orang lain

Jika anda juga berminat dalam perdagangan kuantitatif, cadangan saya ialah:

1. Jangan takut dengan halangan teknikal: Alat semasa sudah sangat berkuasa, yang penting ialah mempunyai idea dan pelaksanaan
2. Mula Kecil: Tidak perlu meneruskan strategi yang sempurna, mula meneroka dengan idea yang mudah
3. Berani mencuba dan gagal: Ia adalah perkara biasa untuk gagal pada kali pertama. Kuncinya ialah menganalisis masalah dan membuat penambahbaikan berterusan.
4. Kekalkan sikap belajar: Beri perhatian lebih kepada sudut pandangan dan teori yang berbeza. Inspirasi sering datang dari tempat yang tidak dijangka.

Kesimpulan

Mengimbas kembali, titik permulaan penerokaan ini hanyalah ulasan tentang Bilibili, tetapi ia membolehkan saya mengalami proses pembangunan strategi kuantitatif yang lengkap.

Dalam era di mana pengetahuan dan alat berada di hujung jari kita, mungkin kita benar-benar kekurangan percubaan yang berani. Sama ada anda seorang pemula kuantitatif atau peniaga yang berpengalaman, anda boleh cuba bermula dengan idea mudah dan melihat ke mana anda boleh pergi.

Strategi menarik seterusnya mungkin tersembunyi dalam ulasan yang baru anda baca.

Penafian: Ini hanyalah perkongsian pengalaman penerokaan peribadi, bukan nasihat pelaburan. Dagangan adalah berisiko, sila buat keputusan dengan berhati-hati.