हर चीज की शुरुआत

मैं कुछ समय से क्वांटिटेटिव ट्रेडिंग कर रहा हूँ। ईमानदारी से कहूँ तो, ज़्यादातर समय मैं दूसरों द्वारा साझा की गई रणनीतियों को पढ़ता हूँ और फिर मापदंडों को संशोधित करने का प्रयास करता हूँ। मेरे पास वास्तव में किसी रणनीति को शुरू से शुरू करने के ज़्यादा अवसर नहीं हैं, मुख्यतः इसलिए क्योंकि मेरे पास कोई अच्छा विचार नहीं है, और विचारों से कोड तक की दूरी काफ़ी दूर लगती है।

कुछ समय पहले मैं खाली था, इसलिए मैंने फिर से बी स्टेशन ब्राउज़ करना शुरू कर दिया। मैंने गलती से भाई ज़ेड का स्टॉक लाइव प्रसारण देखा। मैं इसे बस आकस्मिक रूप से देख रहा था, लेकिन मुझे उम्मीद नहीं थी कि यह मुझे अप्रत्याशित प्रेरणा देगा।

वह अद्भुत सारांश

जब भाई जेड केडीजे संकेतक के बारे में बात कर रहे थे, तो टिप्पणी क्षेत्र में एक नेटिजन ने एक वाक्य पोस्ट किया जो मुझे विशेष रूप से दिलचस्प लगा:

“यदि कीमत थोड़ी गिरती है, तो हुक तेज़ी से गिरता है, जो भविष्य में तेजी के रुझान का संकेत हो सकता है। यदि कीमत तेज़ी से गिरती है, तो हुक धीरे-धीरे गिरता है, जो भविष्य में और गिरावट का संकेत हो सकता है। यदि कीमत थोड़ी बढ़ती है, तो ग्रूव तेज़ी से बढ़ता है, जो भविष्य में मंदी के रुझान का संकेत हो सकता है। यदि कीमत तेज़ी से बढ़ती है, तो हुक धीरे-धीरे बढ़ता है, जो भविष्य में और वृद्धि का संकेत हो सकता है।”

मैं उस समय दंग रह गया था। यह सारांश कितना ज्ञानवर्धक है! हालाँकि यह सिर्फ़ एक वाक्य है, लेकिन यह केडीजे के जे मान के बदलते नियमों को स्पष्ट रूप से समझाता है।

मैंने मन ही मन सोचा, भाई ज़ेड तो शेयर बाज़ार में है, लेकिन यह तर्क क्रिप्टोकरेंसी पर भी लागू होना चाहिए, है ना? जितना ज़्यादा मैंने इसके बारे में सोचा, उतना ही यह समझ में आया। कीमतों में बदलाव की तीव्रता और संकेतकों की प्रतिक्रियाओं की गति, ये दोनों आयाम मिलकर आगे के रुझान का अंदाज़ा लगाने के लिए काफ़ी तार्किक लग रहे थे। इसके अलावा, क्रिप्टोकरेंसी बाज़ार में चौबीसों घंटे कारोबार होता है, और अस्थिरता ज़्यादा होती है, इसलिए शायद यह सिद्धांत बेहतर प्रदर्शन करेगा।

उस समय मैं थोड़ा उत्साहित था, और मुझे लगा कि मुझे तलाशने के लिए एक दिशा मिल गई है। लेकिन फिर मैं फिर से चिंतित हो गया, मैं इस विचार को कोड में कैसे बदल सकता हूँ? अतीत में, जब मैं ऐसी स्थिति का सामना करता था, तो मैं या तो इसके बारे में सोचता था या इसे एक तरफ रख देता था और जब मेरे पास समय होता था, तब इसे करता था।

इसे आजमाने का निर्णय लिया

लेकिन इस बार बात अलग है। मुझे याद आया कि इन्वेंटर प्लेटफ़ॉर्म में एक 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)

पहली बार का उत्साह और निराशा

कोड मिलने के बाद, मैंने सबसे पहले यह जाँचा कि क्या यह चल सकता है। इन्वेंटर प्लेटफ़ॉर्म के संपादक ने बताया कि इसमें कोई सिंटैक्स त्रुटियाँ नहीं हैं, और मुझे राहत मिली।

फिर सबसे रोमांचक क्षण आता है - ऑनलाइन बैकटेस्टिंग। इन्वेंटर एआई असिस्टेंट पेज पर, आप जेनरेट किए गए पेज के निचले दाएं कोने में वास्तविक समय ऑनलाइन बैकटेस्टिंग कर सकते हैं। बैकटेस्ट करेंसी 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 मान विश्लेषण के पूरे तर्क को ही नया रूप दे दिया:

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 मान का परिवर्तन एक अलग बिंदु नहीं रह गया है, बल्कि एक सतत प्रवृत्ति है।

दूसरे बैकटेस्ट का आश्चर्य

नया कोड प्राप्त करने के बाद, मैं एक और बैकटेस्ट करने के लिए इंतजार नहीं कर सका।

इस बार के परिणाम से मैं थोड़ा हैरान था। हालाँकि इसे एक आदर्श रणनीति नहीं कहा जा सकता, लेकिन यह पहले संस्करण से कहीं बेहतर है:

• झूठे संकेत कम होते हैं, क्योंकि निरंतरता की आवश्यकता बहुत सारे शोर को फ़िल्टर कर देती है।
• जीत की दर में उल्लेखनीय सुधार हुआ है
• रणनीति का तर्क स्पष्ट है

बैकटेस्ट रिपोर्ट पर लाभ वक्र को देखते हुए, मुझे उपलब्धि की एक मजबूत भावना महसूस होती है। हालाँकि यह कोई बहुत बड़ी रणनीति नहीं है, लेकिन इसकी शुरुआत एक विचार से हुई और इसे चरण दर चरण परखा गया।

उपकरण उपयोग अनुभव

इस अन्वेषण से मुझे एआई सहायकों और मात्रात्मक प्लेटफार्मों की नई समझ मिली।

एआई सहायकों का मूल्य:

मैं पहले सोचता था कि एआई सिर्फ़ एक कमज़ोर इंटेलिजेंस सहायक उपकरण है, लेकिन इस बार मैंने पाया कि यह मात्रात्मक व्यापार में वास्तव में उपयोगी है। सबसे बड़ा मूल्य मानव सोच को प्रतिस्थापित करना नहीं है, बल्कि विचार से कोड तक की दूरी को बहुत कम करना है।

1. मजबूत समझने की क्षमतामैंने अभी एक विचार को बहुत ही सरल भाषा में वर्णित किया है, और इसे सटीक रूप से समझा जा सकता है और एक पूर्ण रणनीतिक तर्क में परिवर्तित किया जा सकता है
2. तेज़ पुनरावृत्ति गतिजब मैं सुधार के लिए अनुरोध करता हूं, तो यह समस्या का शीघ्र पता लगा सकता है और समाधान प्रदान कर सकता है
3. अच्छी कोड गुणवत्ताउत्पन्न कोड न केवल निष्पादन योग्य है, बल्कि इसमें एक स्पष्ट संरचना और विस्तृत टिप्पणियाँ भी हैं

मात्रात्मक मंच की सुविधा: मैं इन्वेंटर प्लेटफ़ॉर्म के बैकटेस्टिंग फ़ंक्शन से भी प्रभावित था। अतीत में, यदि आप किसी रणनीति का बैकटेस्ट करना चाहते थे, तो आपको ऐतिहासिक डेटा ढूंढना पड़ता था, बैकटेस्टिंग फ्रेमवर्क लिखना पड़ता था, और विभिन्न तकनीकी विवरणों से निपटना पड़ता था। अब आपको केवल कोड पेस्ट करना है, पैरामीटर सेट करना है, और आप तुरंत परिणाम देख सकते हैं।

यह त्वरित फीडबैक संपूर्ण अन्वेषण प्रक्रिया को बहुत सुचारू बना देता है, तथा विचार, कोड, सत्यापन और सुधार एक बहुत तेज़ चक्र बनाते हैं।

कुछ विचार

बेशक, इस अन्वेषण ने मुझे कुछ प्रश्नों के बारे में भी सोचने पर मजबूर किया:

एआई की सीमाएँ: हालाँकि AI ने बहुत मदद की है, लेकिन यह सर्वशक्तिमान नहीं है। AI अकेले कोड के पहले संस्करण की समस्याओं का पता नहीं लगा सकता है, और अभी भी लोगों को विश्लेषण और निर्णय लेने की आवश्यकता है। इसके अलावा, AI द्वारा दिया गया समाधान सबसे अच्छा नहीं हो सकता है, और इसे वास्तविक स्थिति के अनुसार समायोजित करने की आवश्यकता है।

रणनीति की सीमाएँ: हालांकि यह रणनीति बैकटेस्टिंग में अच्छा प्रदर्शन करती है, लेकिन यह रामबाण नहीं है। यह अस्थिर बाजारों में आम तौर पर अच्छा प्रदर्शन करती है, और मापदंडों को विभिन्न मुद्राओं के अनुसार समायोजित करने की आवश्यकता होती है।

सबसे महत्वपूर्ण बात यह है कि सिर्फ़ इसलिए कि कोई रणनीति ऐतिहासिक डेटा में अच्छा प्रदर्शन करती है, यह नहीं माना जा सकता कि यह भविष्य में भी कारगर होगी। बाज़ार बदल रहा है, और रणनीतियों को लगातार समायोजित करने की ज़रूरत है।

एक अप्रत्याशित बोनस

रणनीति के अतिरिक्त, इस अन्वेषण से कुछ अप्रत्याशित लाभ भी प्राप्त हुए:

मात्रात्मक व्यापार की समझ बदल गई है: मैं पहले सोचता था कि मात्रात्मक व्यापार के लिए सीमा बहुत अधिक है, जिसके लिए मजबूत प्रोग्रामिंग कौशल और गणितीय आधार की आवश्यकता होती है। इस अनुभव ने मुझे महसूस कराया कि विचार और तर्क अधिक महत्वपूर्ण हैं। अच्छे उपकरणों के साथ, तकनीकी सीमा उतनी अधिक नहीं है जितनी कल्पना की जाती है।

सीखने के प्रति बदला नजरिया: अतीत में, जब भी मुझे कोई दिलचस्प विचार मिलता था, तो मैं हमेशा सोचता था, “जब मेरे पास समय होगा, तो मैं इसे आज़माऊंगा”, लेकिन यह अक्सर व्यर्थ हो जाता था। इस अनुभव ने मुझे एहसास दिलाया कि मौजूदा साधनों ने “इसे आज़माना” आसान बना दिया है, कुंजी कार्य करने का साहस रखना है।

असफलता के प्रति नजरिया बदल गया है: जब रणनीति का पहला संस्करण ठीक से काम नहीं कर रहा था, तो मैंने तुरंत हार नहीं मानी, बल्कि समस्या का विश्लेषण किया। इस प्रक्रिया ने मुझे एहसास दिलाया कि असफलता अक्सर अंत नहीं होती, बल्कि सही दिशा खोजने का एक संकेत होती है।

आगामी योजनाएँ

यह रणनीति अभी भी मेरे कोड बेस में है और मैं कभी-कभी इसका इस्तेमाल करता हूँ। हालाँकि यह एक आदर्श रणनीति नहीं है, लेकिन अन्वेषण के परिणामस्वरूप मैं इससे काफी संतुष्ट हूँ।

इससे भी ज़्यादा महत्वपूर्ण बात यह है कि इस अनुभव ने मुझे आत्मविश्वास दिया। अब पता चला कि विचार और रणनीति के बीच का अंतर उतना नहीं है जितना मैंने सोचा था।

अब मैं इस अन्वेषण को जारी रखना चाहूँगा:

• कुछ दिलचस्प व्यापारिक सिद्धांतों और विचारों पर अधिक ध्यान दें
• अन्य क्षेत्रों की कुछ अवधारणाओं को ट्रेडिंग में लागू करने का प्रयास करें
• विचारों को शीघ्रता से सत्यापित करने के लिए एआई और मात्रात्मक प्लेटफार्मों का लाभ उठाना जारी रखें

दूसरों के लिए सलाह

यदि आप भी मात्रात्मक व्यापार में रुचि रखते हैं, तो मेरे सुझाव हैं:

1. तकनीकी बाधाओं से घबराएँ नहींवर्तमान उपकरण पहले से ही बहुत शक्तिशाली हैं, जो मायने रखता है वह है विचार और कार्यान्वयन
2. छोटा शुरू करो: किसी आदर्श रणनीति की आवश्यकता नहीं, सरल विचारों से अन्वेषण शुरू करें
3. कोशिश करने और असफल होने का साहस रखेंपहली बार में असफल होना सामान्य बात है। मुख्य बात यह है कि समस्या का विश्लेषण करें और निरंतर सुधार करते रहें।
4. सीखने का रवैया रखेंविभिन्न दृष्टिकोणों और सिद्धांतों पर अधिक ध्यान दें। प्रेरणा अक्सर अप्रत्याशित स्थानों से आती है।

निष्कर्ष

पीछे मुड़कर देखें तो इस अन्वेषण का प्रारंभिक बिंदु बिलिबिली पर एक टिप्पणी मात्र था, लेकिन इसने मुझे संपूर्ण मात्रात्मक रणनीति विकास प्रक्रिया का अनुभव करने का अवसर दिया।

इस युग में जहाँ ज्ञान और उपकरण हमारी उंगलियों पर हैं, शायद हमारे पास वास्तव में साहसपूर्ण प्रयास की कमी है। चाहे आप मात्रात्मक नौसिखिए हों या अनुभवी व्यापारी, आप एक सरल विचार से शुरुआत करने की कोशिश कर सकते हैं और देख सकते हैं कि आप कहाँ तक पहुँच सकते हैं।

अगली दिलचस्प रणनीति शायद आपके द्वारा अभी पढ़ी गई टिप्पणी में छिपी हो।

अस्वीकरण: यह सिर्फ़ एक निजी अनुभव साझा है, निवेश सलाह नहीं। ट्रेडिंग जोखिम भरा है, कृपया सोच-समझकर निर्णय लें।