모든 것의 시작

저는 한동안 퀀트 트레이딩을 해왔습니다. 솔직히 말해서, 대부분 다른 사람들이 공유한 전략을 읽고 나서 변수를 수정해 보려고 노력합니다. 전략을 처음부터 제대로 시작할 기회가 많지 않은데, 좋은 아이디어가 없고, 아이디어에서 코드로 구현하는 과정이 너무 멀게 느껴지기 때문입니다.

얼마 전 시간이 나서 B 스테이션을 다시 둘러보기 시작했는데, 우연히 Brother Z의 스톡 생방송을 봤어요. 그냥 무심코 보고 있었는데, 예상치 못한 영감을 받을 줄은 몰랐어요.

그 놀라운 요약

Z형님이 KDJ 지표에 대해 이야기하시던 중, 댓글란에 어떤 네티즌이 제가 특히 흥미롭게 읽은 글을 올렸습니다.

가격이 소폭 하락하면 후크가 빠르게 하락하는데, 이는 향후 강세 추세를 시사할 수 있습니다. 가격이 급락하면 후크가 느리게 하락하는데, 이는 향후 추가 하락을 시사할 수 있습니다. 가격이 소폭 상승하면 그루브가 빠르게 상승하는데, 이는 향후 약세 추세를 시사할 수 있습니다. 가격이 급등하면 후크가 느리게 상승하는데, 이는 향후 추가 상승을 시사할 수 있습니다.

당시 정말 깜짝 놀랐어요. 이 요약 정말 통찰력 있네요! 비록 한 문장이지만 KDJ의 J 값의 변화하는 규칙을 명확하게 설명하는 것 같아요.

‘형 Z는 주식 시장에 있는데, 이 논리는 암호화폐에도 적용되어야 하지 않을까?‘라는 생각이 들었습니다. 곰곰이 생각해 보니, 가격 변동의 규모와 지표 반응 속도, 이 두 가지 측면을 종합적으로 고려하여 이후 추세를 판단하는 것이 매우 논리적으로 들렸습니다. 게다가 암호화폐 시장은 24시간 거래되고 변동성이 크기 때문에 이 이론이 더 타당할 수도 있습니다.

그 순간, 저는 약간 흥분했고, 탐구할 방향을 찾았다고 느꼈습니다. 하지만 다시 걱정이 생겼습니다. 이 아이디어를 어떻게 코드로 구현할 수 있을까? 예전에는 그런 상황에 직면하면, 그냥 생각하거나, 아니면 미뤄두고 시간이 날 때 하려고 했습니다.

시도해보기로 결정했다

하지만 이번에는 달랐습니다. Inventor Platform에 AI 비서가 있다는 걸 기억해 냈고, 그래서 이 아이디어를 코드로 직접 “번역”할 수 있는지 시험해 보고 싶었습니다.

시도해 보겠다는 마음으로 인벤터 플랫폼의 AI 비서를 켜고 아이디어를 그대로 입력한 뒤, 이렇게 덧붙였습니다. “이 이론은 주식에 적용한 것이고, 암호화폐에도 적용해 보고 싶습니다.”

AI가 그렇게 빨리 이해하고 제게 필요한 전략 코드를 완벽하게 생성해 줄 줄은 몰랐습니다. 그 순간, 저는 꽤 놀랐고, ‘이제 AI가 이렇게 강력해진 건가?‘라는 생각이 들었습니다.

전략 코드의 첫 번째 버전:

/*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)

첫 경험의 설렘과 실망

코드를 받은 후 가장 먼저 한 일은 실행이 되는지 확인하는 것이었습니다. Inventor Platform 편집자가 구문 오류가 없다고 알려줘서 안심했습니다.

이제 가장 흥미로운 순간, 바로 온라인 백테스팅입니다. Inventor AI Assistant 페이지에서 생성된 페이지 오른쪽 하단에서 실시간 온라인 백테스팅을 수행할 수 있습니다. 백테스팅 통화인 BTC를 선택하고, 기간 범위를 설정한 후, 온라인 백테스팅 버튼을 클릭하세요.

결과가 나온 후, 좀 헷갈렸습니다. 코드는 잘 작동했고 로직도 맞는 것 같았지만, 백테스트 결과는 완벽하지 않았습니다. 수익을 낼 때도 있었지만, 전체적인 승률은 높지 않았고, 연달아 손실을 보는 경우가 많았습니다.

이론상으로는 날 수 있는 비행기가 만들어졌는데, 결국 날지 못하는 것 같았다. 조금 실망스러웠지만, 포기할 생각은 없었다.

생각에 빠지다

이론이 합리적이고 코드가 작동한다면, 문제는 무엇일까?

코드의 논리를 면밀히 분석하기 시작했습니다. AI가 작성한 코드는 주로 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

처음 보기에는 아무 문제가 없는 것 같지만, 저는 항상 뭔가 잘못된 것이 있다는 느낌을 받습니다.

생각해 보니 갑자기 문제가 하나 생겼습니다. 이 계산은 특정 순간의 변화 속도만을 고려하고, 변화의 속도는 고려하지 않는다는 것입니다.연속성。

예를 들어, J 값은 특정 날에 급격하게 변할 수 있지만, 이는 일시적인 현상일 뿐 다음 날 정상으로 돌아오는 경우가 있습니다. 이 경우, 단일 지점의 속도만으로 판단하는 것은 정확하지 않을 수 있습니다.

원래 이론은 “빠르게 끊는다”와 “느리게 끊는다”라고 합니다. “빠르다”와 “느리다”는 특정 시점의 상태가 아니라 지속적인 과정을 지칭해야 합니다.

돌파구 찾기

이 문제를 깨닫고 나니 다시 조금 흥분이 됐습니다. 열쇠를 찾은 것 같았지만, 코드를 어떻게 바꿔야 할지 몰랐거든요.

이때, 전에 봤던 댓글 몇 개가 생각났습니다. 누군가 지표 변화의 연속성에 주의를 기울여야 한다고 말했던 것 같습니다. 네, 연속성이죠! 바로 제가 생각했던 것과 똑같았습니다.

AI 비서에게 돌아가 이번에는 명확하게 요청했습니다. J 값 변화의 연속성을 강조해야 합니다. 단일 지점의 변화 속도만 볼 것이 아니라, 며칠 연속으로 나타나는 변화 추세를 살펴봐야 합니다.

이번에 AI가 제시한 해결책은 놀라웠습니다. J 값 분석의 전체 논리를 재설계한 것입니다.

1. 현재 변화 방향을 기록할 뿐만 아니라, 연속된 변화 일수도 추적합니다.
2. 추세가 며칠 연속으로 같은 방향으로 바뀔 때에만 유효한 추세로 간주됩니다.
3. 연속성을 확인한 후에야 변화의 속도를 판단할 수 있습니다.

전략 코드의 두 번째 개선된 버전:

/*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值连续性背景")

이러한 개선을 보고 “바로 이거야”라는 생각이 들었어요. 이제 J 값의 변화는 더 이상 고립된 지점이 아니라 지속적인 추세를 보이고 있습니다.

두 번째 백테스트의 놀라움

새로운 코드를 받은 후, 다시 백테스트를 해보고 싶어졌습니다.

이번 결과에 조금 놀랐습니다. 완벽한 전략이라고는 할 수 없지만, 첫 번째 버전보다는 확실히 훨씬 나아졌습니다.

• 연속성에 대한 요구 사항으로 인해 많은 노이즈가 걸러지므로 거짓 신호가 줄어듭니다.
• 승률이 크게 향상되었습니다
• 전략 논리가 더 명확해졌습니다

백테스트 보고서의 수익 곡선을 보면 강한 성취감이 느껴집니다. 엄청난 전략은 아니지만, 아이디어에서 시작해서 차근차근 탐구해 나갔습니다.

도구 사용 경험

이 탐구를 통해 AI 비서와 양적 플랫폼에 대한 새로운 이해를 얻었습니다.

AI 비서의 가치:

예전에는 AI가 그저 지능을 보조하는 도구일 뿐이라고 생각했는데, 이번에는 양적 거래에 정말 유용하다는 것을 알게 되었습니다. AI의 가장 큰 가치는 인간의 사고를 대체하는 것이 아니라, 아이디어에서 코드로 구현되는 과정을 크게 단축하는 것입니다.

1. 강력한 이해 능력: 방금 아주 간단한 언어로 아이디어를 설명했는데, 이는 정확하게 이해되고 완전한 전략적 논리로 변환될 수 있습니다.
2. 빠른 반복 속도: 개선 요청을 하면 문제점을 빠르게 찾아내고 해결책을 제시해 줍니다.
3. 좋은 코드 품질：생성된 코드는 실행 가능할 뿐만 아니라 명확한 구조와 자세한 주석을 가지고 있습니다.

정량적 플랫폼의 편의성: Inventor 플랫폼의 백테스팅 기능도 인상적이었습니다. 과거에는 전략을 백테스팅하려면 과거 데이터를 찾고, 백테스팅 프레임워크를 개발하고, 다양한 기술적 세부 사항을 처리해야 했습니다. 이제는 코드를 붙여넣고 매개변수만 설정하면 결과를 즉시 확인할 수 있습니다.

이러한 즉각적인 피드백 덕분에 전체 탐색 과정이 매우 원활해지고, 아이디어, 코드, 검증, 개선이 매우 빠른 순환을 형성합니다.

몇 가지 반성

물론, 이 탐구는 저에게 몇 가지 질문을 떠올리게 했습니다.

AI의 한계: AI가 많은 도움을 주긴 했지만, 결국 만능은 아닙니다. AI는 초기 버전의 코드에서 문제점을 스스로 찾아낼 수 없으며, 여전히 사람의 분석과 판단이 필요합니다. 더욱이 AI가 제시하는 해결책이 최선의 해결책이 아닐 수 있으며, 실제 상황에 맞게 조정해야 합니다.

전략 자체의 한계: 이 전략은 백테스팅에서는 좋은 성과를 보이지만, 만병통치약은 아닙니다. 변동성이 큰 시장에서는 전반적으로 좋은 성과를 보이며, 환율에 따라 매개변수를 조정해야 합니다.

가장 중요한 것은 전략이 과거 데이터에서 좋은 성과를 보였다고 해서 미래에도 효과적일 것이라고 단정 지을 수는 없다는 것입니다. 시장은 끊임없이 변화하고 있으며, 전략은 끊임없이 조정되어야 합니다.

예상치 못한 보너스

전략 자체 외에도 이 탐색을 통해 예상치 못한 성과도 얻었습니다.

양적 거래에 대한 이해가 바뀌었습니다. 예전에는 양적 거래의 문턱이 매우 높아서 탄탄한 프로그래밍 기술과 수학적 기초가 필요하다고 생각했습니다. 하지만 이 경험을 통해 아이디어와 논리가 더 중요하다는 것을 깨달았습니다. 좋은 도구를 사용하면 기술적 문턱이 생각보다 높지 않습니다.

학습에 대한 태도 변화: 예전에는 흥미로운 아이디어를 접할 때마다 “시간 나면 해봐야지”라고 생각했지만, 결국에는 허사로 끝나는 경우가 많았습니다. 이 경험을 통해 지금의 도구들이 “한번 시도해 보는” 것을 쉽게 만들어 준다는 것을 깨달았습니다. 중요한 것은 행동할 용기를 갖는 것입니다.

실패에 대한 관점이 바뀌었습니다. 첫 번째 전략이 제대로 작동하지 않았을 때, 저는 바로 포기하지 않고 문제를 분석했습니다. 이 과정을 통해 실패는 종종 끝이 아니라 올바른 방향을 찾는 단서가 된다는 것을 깨달았습니다.

이후 계획

이 전략은 아직 제 코드 베이스에 저장되어 있고 가끔 사용합니다. 완벽한 전략은 아니지만, 여러 가지를 시도해 본 결과 꽤 만족하고 있습니다.

더 중요한 것은, 이 경험이 제게 자신감을 심어주었다는 것입니다. 아이디어에서 전략으로 이어지는 거리가 제가 생각했던 것만큼 멀지 않다는 것을 알게 되었습니다.

다음으로 이 탐색을 계속하고 싶습니다.

• 흥미로운 거래 이론과 아이디어에 더 많은 관심을 기울이십시오.
• 다른 분야의 개념을 거래에 적용해보세요.
• AI와 정량적 플랫폼을 지속적으로 활용하여 아이디어를 빠르게 검증합니다.

다른 사람들을 위한 조언

만약 당신도 양적 거래에 관심이 있다면, 제가 추천하는 것은 다음과 같습니다.

1. 기술적 장벽에 겁먹지 마세요: 현재 도구는 이미 매우 강력하지만 중요한 것은 아이디어와 실행입니다.
2. 작게 시작하세요: 완벽한 전략을 추구할 필요 없이 간단한 아이디어로 탐색을 시작하세요
3. 용기를 내어 시도하고 실패하세요: 처음에 실패하는 것은 당연한 일입니다. 중요한 것은 문제를 분석하고 지속적으로 개선하는 것입니다.
4. 학습 태도를 유지하세요: 다양한 관점과 이론에 더 주의를 기울이세요. 영감은 종종 예상치 못한 곳에서 찾아옵니다.

결론

돌이켜보면, 이 탐구의 출발점은 단지 빌리빌리에 대한 코멘트였지만, 이를 통해 완전한 정량적 전략 개발 과정을 경험할 수 있었습니다.

지식과 도구가 손안에 있는 이 시대에, 어쩌면 우리에게는 용감한 시도가 부족한 것일지도 모릅니다. 계량 투자 초보자든 경험 많은 트레이더든, 간단한 아이디어부터 시작해서 어디까지 갈 수 있는지 확인해 보세요.

다음의 흥미로운 전략은 여러분이 방금 읽은 댓글 속에 숨겨져 있을지도 모릅니다.

면책 조항: 본 내용은 개인적인 경험 공유일 뿐이며, 투자 조언이 아닙니다. 투자는 위험하므로 신중하게 결정하시기 바랍니다.