Sự khởi đầu của mọi thứ

Tôi đã giao dịch định lượng một thời gian. Thành thật mà nói, hầu hết thời gian tôi chỉ đọc các chiến lược được người khác chia sẻ và sau đó cố gắng sửa đổi các thông số. Tôi không có nhiều cơ hội để thực sự bắt đầu một chiến lược từ đầu, chủ yếu là vì tôi không có bất kỳ ý tưởng hay nào và khoảng cách từ ý tưởng đến mã có vẻ khá xa.

Tôi đã rảnh rỗi một thời gian trước, vì vậy tôi bắt đầu duyệt B station một lần nữa. Tôi vô tình thấy chương trình phát sóng trực tiếp của Brother Z. Tôi chỉ xem một cách hời hợt, nhưng tôi không ngờ nó lại mang đến cho tôi nguồn cảm hứng bất ngờ.

Tóm tắt tuyệt vời đó

Khi anh Z đang nói về chỉ số KDJ, một cư dân mạng đã đăng một câu trong phần bình luận mà tôi thấy đặc biệt thú vị:

“Nếu giá giảm nhẹ, móc sẽ giảm nhanh, điều này có thể chỉ ra xu hướng tăng trong tương lai. Nếu giá giảm mạnh, móc sẽ giảm chậm, điều này có thể chỉ ra xu hướng giảm tiếp theo trong tương lai. Nếu giá tăng nhẹ, rãnh sẽ phát triển nhanh, điều này có thể chỉ ra xu hướng giảm trong tương lai. Nếu giá tăng mạnh, móc sẽ tăng chậm, điều này có thể chỉ ra xu hướng tăng tiếp theo trong tương lai.”

Lúc đó tôi đã sửng sốt. Bản tóm tắt này thật sâu sắc! Mặc dù chỉ là một câu, nhưng có vẻ như nó giải thích rõ ràng các quy tắc thay đổi của giá trị J của KDJ.

Tôi tự nhủ, Anh Z đang ở trong thị trường chứng khoán, nhưng logic này cũng nên áp dụng cho tiền điện tử, đúng không? Càng nghĩ về nó, tôi càng thấy hợp lý. Quy mô thay đổi giá và tốc độ phản ứng của chỉ báo, hai chiều này kết hợp để đánh giá xu hướng tiếp theo, nghe có vẻ rất hợp lý. Hơn nữa, thị trường tiền điện tử được giao dịch 24 giờ một ngày và tính biến động lớn hơn, vì vậy có lẽ lý thuyết này sẽ hoạt động tốt hơn.

Lúc đó tôi hơi phấn khích, cảm thấy mình đã tìm được hướng đi để khám phá. Nhưng rồi tôi lại lo lắng, làm sao để biến ý tưởng này thành code? Trước đây, khi gặp phải tình huống như vậy, tôi sẽ hoặc là nghĩ về nó, hoặc là gác lại và làm khi có thời gian.

Quyết định thử xem sao

Nhưng lần này thì khác. Tôi nhớ rằng Inventor Platform có trợ lý AI, nên tôi muốn thử xem liệu tôi có thể “dịch” trực tiếp ý tưởng này thành mã hay không.

Với thái độ muốn thử nghiệm, tôi đã mở trợ lý AI của Inventor Platform, nhập nguyên văn ý tưởng và thêm vào: Đây là lý thuyết áp dụng cho cổ phiếu và tôi muốn thử nghiệm trên tiền điện tử.

Tôi không ngờ AI lại hiểu nhanh như vậy, còn nhanh chóng tạo ra một bộ mã chiến lược hoàn chỉnh cho tôi, lúc đó tôi khá bất ngờ và nghĩ, AI bây giờ mạnh mẽ như vậy sao?

Phiên bản đầu tiên của mã chiến lược:

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

Sự phấn khích và thất vọng của lần đầu tiên

Sau khi nhận được mã, điều đầu tiên tôi làm là kiểm tra xem nó có chạy được không. Trình biên tập của Inventor Platform cho biết không có lỗi cú pháp nào và tôi đã thở phào nhẹ nhõm.

Sau đó đến khoảnh khắc thú vị nhất - kiểm tra ngược trực tuyến. Trên trang Trợ lý AI của Inventor, bạn có thể thực hiện kiểm tra ngược trực tuyến theo thời gian thực ở góc dưới bên phải của trang đã tạo. Chọn loại tiền tệ kiểm tra ngược là BTC, đặt phạm vi thời gian và nhấp vào nút kiểm tra ngược trực tuyến.

Sau khi kết quả ra, tôi cảm thấy hơi hỗn loạn. Mã đã chạy và logic có vẻ đúng, nhưng kết quả kiểm tra ngược lại không lý tưởng. Mặc dù có lúc tôi kiếm được lợi nhuận, nhưng tỷ lệ chiến thắng chung không cao và tôi thường xuyên bị thua lỗ liên tiếp.

Cảm giác như một chiếc máy bay có thể bay theo lý thuyết đã được chế tạo nhưng cuối cùng lại không thể bay. Tôi cảm thấy hơi thất vọng, nhưng tôi không muốn từ bỏ.

Rơi vào suy nghĩ

Nếu lý thuyết có lý và mã hoạt động thì vấn đề ở đây là gì?

Tôi bắt đầu nghiên cứu logic của mã một cách cẩn thận. Tôi thấy rằng mã do AI viết chủ yếu đánh giá “nhanh” và “chậm” bằng cách tính toán tốc độ thay đổi của giá trị 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

Thoạt nhìn thì có vẻ không có gì sai, nhưng tôi luôn cảm thấy có điều gì đó không ổn.

Sau khi suy nghĩ về điều đó, tôi đột nhiên nhận ra một vấn đề: phép tính này chỉ xem xét tốc độ thay đổi tại một thời điểm nhất định, nhưng không tính đến sự thay đổi củaTính liên tục。

Ví dụ, giá trị J có thể thay đổi nhanh chóng vào một ngày nào đó, nhưng nó chỉ là một chớp nhoáng trong chảo và trở lại bình thường vào ngày hôm sau. Trong trường hợp này, việc đánh giá theo tốc độ của một điểm duy nhất có thể không chính xác.

Lý thuyết ban đầu nói rằng “móc nhanh” và “móc chậm”. “Nhanh” và “chậm” ở đây nên ám chỉ một quá trình liên tục chứ không phải trạng thái tại một thời điểm nhất định.

Tìm thấy một bước đột phá

Sau khi nhận ra vấn đề này, tôi lại có chút phấn khích. Tôi cảm thấy như mình đã tìm thấy chìa khóa, nhưng tôi không biết cách thay đổi mã.

Lúc này, tôi nhớ lại một số bình luận tôi đã thấy trước đó, có người nói rằng chúng ta nên chú ý đến tính liên tục của các thay đổi chỉ báo. Đúng vậy, tính liên tục! Đây chính xác là điều tôi đang nghĩ đến.

Tôi quay lại với trợ lý AI và lần này tôi đưa ra yêu cầu rõ ràng: chúng ta phải làm nổi bật tính liên tục của sự thay đổi trong giá trị J. Chúng ta không thể chỉ xem xét tốc độ thay đổi của một điểm duy nhất mà phải xem xét xu hướng thay đổi trong nhiều ngày liên tiếp.

Giải pháp do AI cung cấp lần này đã mở mang tầm mắt. Nó đã thiết kế lại toàn bộ logic của phân tích giá trị J:

1. Không chỉ ghi lại hướng thay đổi hiện tại mà còn theo dõi số ngày thay đổi liên tiếp
2. Chỉ khi xu hướng thay đổi theo cùng một hướng trong nhiều ngày liên tiếp thì mới được coi là xu hướng hợp lệ.
3. Sau khi xác nhận tính liên tục, chúng ta có thể đánh giá tốc độ thay đổi.

Phiên bản cải tiến thứ hai của mã chiến lược:

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

Nhìn thấy sự cải thiện này, tôi cảm thấy phấn khích rằng “đây chính là cảm giác”. Bây giờ sự thay đổi của giá trị J không còn là một điểm riêng lẻ nữa mà là một xu hướng liên tục.

Sự ngạc nhiên của lần kiểm tra ngược thứ hai

Sau khi nhận được mã mới, tôi không thể chờ đợi để thực hiện một lần kiểm tra ngược khác.

Tôi hơi bất ngờ về kết quả lần này. Mặc dù không thể nói là chiến lược hoàn hảo, nhưng rõ ràng là tốt hơn nhiều so với phiên bản đầu tiên:

• Có ít tín hiệu sai hơn vì yêu cầu về tính liên tục giúp lọc bỏ nhiều nhiễu.
• Tỷ lệ chiến thắng đã được cải thiện đáng kể
• Logic chiến lược rõ ràng hơn

Nhìn vào đường cong lợi nhuận trên báo cáo kiểm tra ngược, tôi cảm thấy có cảm giác thành tựu mạnh mẽ. Mặc dù đây không phải là một chiến lược gây chấn động thế giới, nhưng nó bắt đầu bằng một ý tưởng và được khám phá từng bước một.

Kinh nghiệm sử dụng công cụ

Khám phá này đã mang lại cho tôi hiểu biết mới về trợ lý AI và nền tảng định lượng.

Giá trị của trợ lý AI:

Tôi từng nghĩ AI chỉ là công cụ hỗ trợ trí tuệ yếu, nhưng lần này tôi thấy nó thực sự hữu ích trong giao dịch định lượng. Giá trị lớn nhất không phải là thay thế tư duy của con người, mà là rút ngắn đáng kể khoảng cách từ ý tưởng đến mã.

1. Khả năng hiểu biết mạnh mẽ:Tôi chỉ sử dụng ngôn ngữ rất đơn giản để mô tả một ý tưởng, và nó có thể được hiểu chính xác và chuyển đổi thành một logic chiến lược hoàn chỉnh
2. Tốc độ lặp lại nhanh: Khi tôi đưa ra yêu cầu cải tiến, nó có thể nhanh chóng xác định được vấn đề và đưa ra giải pháp
3. Chất lượng mã tốt：Mã được tạo ra không chỉ có thể thực thi được mà còn có cấu trúc rõ ràng và các chú thích chi tiết

Sự tiện lợi của nền tảng định lượng: Tôi cũng ấn tượng với chức năng kiểm tra ngược của nền tảng Inventor. Trước đây, nếu bạn muốn kiểm tra ngược một chiến lược, bạn phải tìm dữ liệu lịch sử, viết một khuôn khổ kiểm tra ngược và xử lý nhiều chi tiết kỹ thuật khác nhau. Bây giờ bạn chỉ cần dán mã vào, thiết lập các tham số và bạn có thể thấy kết quả ngay lập tức.

Phản hồi tức thời này giúp toàn bộ quá trình khám phá diễn ra suôn sẻ, với các ý tưởng, mã, xác minh và cải tiến hình thành một chu trình rất nhanh.

Một số suy ngẫm

Tất nhiên, cuộc khám phá này cũng khiến tôi nghĩ đến một số câu hỏi:

Hạn chế của AI: Mặc dù AI đã giúp đỡ rất nhiều, nhưng dù sao nó cũng không phải là toàn năng. AI không thể tự mình tìm ra vấn đề của phiên bản đầu tiên của mã, vẫn cần mọi người phân tích và đánh giá. Hơn nữa, giải pháp mà AI đưa ra có thể không phải là tốt nhất, và cần phải điều chỉnh theo tình hình thực tế.

Những hạn chế của chiến lược này: Mặc dù chiến lược này hoạt động tốt trong quá trình kiểm tra ngược, nhưng nó không phải là thuốc chữa bách bệnh. Nó thường hoạt động tốt trong các thị trường biến động và các thông số cần được điều chỉnh theo các loại tiền tệ khác nhau.

Điều quan trọng nhất là chỉ vì một chiến lược hoạt động tốt trong dữ liệu lịch sử, không thể cho rằng nó sẽ hiệu quả trong tương lai. Thị trường đang thay đổi và các chiến lược cần phải được điều chỉnh liên tục.

Một phần thưởng bất ngờ

Ngoài chiến lược này, cuộc khám phá này còn mang lại một số lợi ích bất ngờ:

Sự hiểu biết về giao dịch định lượng đã thay đổi: Tôi từng nghĩ ngưỡng giao dịch định lượng rất cao, đòi hỏi kỹ năng lập trình và nền tảng toán học vững chắc. Trải nghiệm này khiến tôi cảm thấy ý tưởng và logic quan trọng hơn. Với các công cụ tốt, ngưỡng kỹ thuật không cao như tưởng tượng.

Thay đổi thái độ học tập: Trước đây, khi gặp những ý tưởng thú vị, tôi luôn nghĩ rằng “Mình sẽ thử khi có thời gian”, nhưng thường thì kết thúc trong vô vọng. Trải nghiệm này khiến tôi nhận ra rằng các công cụ hiện tại đã giúp việc “thử” trở nên dễ dàng, điều quan trọng là phải có can đảm để hành động.

Quan điểm về thất bại đã thay đổi: Khi phiên bản đầu tiên của chiến lược không hiệu quả, tôi không từ bỏ ngay lập tức mà phân tích vấn đề. Quá trình này khiến tôi nhận ra rằng thất bại thường không phải là kết thúc, mà là manh mối để tìm ra hướng đi đúng đắn.

Kế hoạch tiếp theo

Chiến lược này vẫn nằm trong cơ sở mã của tôi và tôi thỉnh thoảng sử dụng nó. Mặc dù nó không phải là một chiến lược hoàn hảo, nhưng tôi khá hài lòng với nó sau khi khám phá.

Quan trọng hơn, trải nghiệm này đã cho tôi sự tự tin. Hóa ra khoảng cách từ ý tưởng đến chiến lược không xa như tôi tưởng tượng.

Tiếp theo tôi muốn tiếp tục khám phá này:

• Hãy chú ý nhiều hơn đến một số lý thuyết và ý tưởng giao dịch thú vị
• Cố gắng áp dụng một số khái niệm từ các lĩnh vực khác vào giao dịch
• Tiếp tục tận dụng AI và các nền tảng định lượng để nhanh chóng xác thực ý tưởng

Lời khuyên cho người khác

Nếu bạn cũng quan tâm đến giao dịch định lượng, tôi xin gợi ý:

1. Đừng để bị đe dọa bởi các rào cản kỹ thuật:Các công cụ hiện tại đã rất mạnh mẽ, điều quan trọng là có ý tưởng và thực hiện
2. Bắt đầu nhỏ: Không cần phải theo đuổi một chiến lược hoàn hảo, hãy bắt đầu khám phá bằng những ý tưởng đơn giản
3. Hãy dũng cảm thử và thất bại: Thất bại lần đầu là điều bình thường. Điều quan trọng là phân tích vấn đề và liên tục cải tiến.
4. Giữ thái độ học hỏi: Hãy chú ý nhiều hơn đến các quan điểm và lý thuyết khác nhau. Cảm hứng thường đến từ những nơi không ngờ tới.

Phần kết luận

Nhìn lại, điểm khởi đầu của cuộc khám phá này chỉ là một bình luận về Bilibili, nhưng nó đã cho phép tôi trải nghiệm toàn bộ quá trình phát triển chiến lược định lượng.

Trong thời đại mà kiến ​​thức và công cụ nằm trong tầm tay, có lẽ chúng ta thực sự thiếu một nỗ lực dũng cảm. Cho dù bạn là người mới bắt đầu định lượng hay là một nhà giao dịch có kinh nghiệm, bạn có thể thử bắt đầu với một ý tưởng đơn giản và xem bạn có thể đi đến đâu.

Chiến lược thú vị tiếp theo có thể ẩn trong bình luận bạn vừa đọc.

Tuyên bố miễn trừ trách nhiệm: Đây chỉ là chia sẻ kinh nghiệm khám phá cá nhân, không phải lời khuyên đầu tư. Giao dịch có rủi ro, vui lòng đưa ra quyết định cẩn thận.