Le début de tout

Je pratique le trading quantitatif depuis un certain temps. Pour être honnête, la plupart du temps, je me contente de lire les stratégies partagées par d’autres, puis j’essaie d’en modifier les paramètres. Je n’ai pas souvent l’occasion de vraiment créer une stratégie de toutes pièces, principalement parce que je n’ai pas de bonnes idées, et la distance entre les idées et le code me semble assez grande.

J’étais libre il y a quelque temps, alors j’ai recommencé à parcourir la station B. J’ai par hasard vu l’émission en direct de Brother Z. Je la regardais simplement par hasard, mais je ne m’attendais pas à ce qu’elle me donne une inspiration inattendue.

Ce résumé incroyable

Lorsque Brother Z parlait de l’indicateur KDJ, un internaute dans la zone de commentaires a posté une phrase que j’ai trouvée particulièrement intéressante :

Si le prix baisse légèrement, le crochet descend rapidement, ce qui peut indiquer une tendance haussière future. Si le prix chute brusquement, le crochet descend lentement, ce qui peut indiquer une nouvelle baisse future. Si le prix augmente légèrement, le sillon s’élargit rapidement, ce qui peut indiquer une tendance baissière future. Si le prix augmente brusquement, le crochet s’élargit lentement, ce qui peut indiquer une nouvelle hausse future.

J’étais stupéfait à l’époque. Ce résumé est tellement instructif ! Bien qu’il ne tienne qu’une seule phrase, il semble expliquer clairement les règles changeantes de la valeur J de KDJ.

Je me suis dit : « Frère Z est en bourse, mais cette logique devrait aussi s’appliquer aux cryptomonnaies, non ? » Plus j’y réfléchissais, plus cela me semblait logique. L’ampleur des variations de prix et la rapidité de réaction des indicateurs, deux dimensions combinées pour juger de la tendance, me semblaient très logiques. De plus, le marché des cryptomonnaies est négocié 24 heures sur 24 et sa volatilité est plus élevée, donc cette théorie pourrait être plus performante.

À ce moment-là, j’étais un peu enthousiaste et je sentais que j’avais trouvé une voie à explorer. Mais ensuite, je me suis de nouveau inquiété : comment traduire cette idée en code ? Avant, face à une telle situation, soit j’y réfléchissais, soit je la mettais de côté et je la mettais en pratique quand j’en avais le temps.

J’ai décidé de l’essayer

Mais cette fois, c’est différent. Je me suis souvenu que la plateforme Inventor disposait d’un assistant IA, alors j’ai voulu voir si je pouvais traduire directement cette idée en code.

Avec une attitude d’essai, j’ai ouvert l’assistant IA de la plateforme Inventor, j’ai saisi l’idée textuellement et j’ai ajouté : Il s’agit d’une théorie appliquée aux actions, et je veux l’essayer sur les crypto-monnaies.

Je ne m’attendais pas à ce que l’IA comprenne si vite et génère un ensemble complet de codes stratégiques pour moi. À ce moment-là, j’ai été assez surpris et je me suis demandé : l’IA est-elle si puissante maintenant ?

La première version du code de stratégie :

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

L’excitation et la déception de la première fois

Après avoir reçu le code, j’ai d’abord vérifié son exécution. L’éditeur de la plateforme Inventor m’a indiqué qu’il n’y avait aucune erreur de syntaxe, et j’en ai été soulagé.

Vient ensuite le moment le plus passionnant : le backtesting en ligne. Sur la page de l’assistant Inventor AI, vous pouvez effectuer un backtesting en ligne en temps réel dans le coin inférieur droit de la page générée. Sélectionnez la devise de backtest, le BTC, définissez la période, puis cliquez sur le bouton « backtesting en ligne ».

Après la publication des résultats, j’étais un peu mitigé. Le code fonctionnait et la logique semblait correcte, mais les résultats des backtests n’étaient pas parfaits. Même si j’ai parfois réalisé des bénéfices, le taux de réussite global était faible et j’ai souvent subi des pertes consécutives.

J’avais l’impression qu’un avion censé voler avait été construit, mais finalement, il n’a pas pu voler. J’étais un peu déçu, mais je ne voulais pas abandonner.

Tomber dans la pensée

Si la théorie a du sens et que le code fonctionne, quel est le problème ?

J’ai commencé à étudier attentivement la logique du code. J’ai découvert que le code écrit par l’IA juge principalement « rapide » et « lent » en calculant la vitesse de variation de la valeur 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

À première vue, il ne semble y avoir aucun problème, mais j’ai toujours l’impression que quelque chose ne va pas.

Après y avoir réfléchi, je me suis soudain rendu compte d’un problème : ce calcul ne prend en compte que la vitesse de changement à un certain moment, mais ne prend pas en compte le changement deContinuité。

Par exemple, la valeur J peut varier rapidement un jour donné, mais ce n’est qu’un éclair et revient à la normale le lendemain. Dans ce cas, se fier à la vitesse d’un seul point peut s’avérer inexact.

La théorie originale parle de « décrochage rapide » et de « décrochage lent ». Les termes « rapide » et « lent » devraient faire référence à un processus continu plutôt qu’à l’état à un moment donné.

Trouver une percée

Après avoir réalisé ce problème, j’étais de nouveau un peu excité. J’avais l’impression d’avoir trouvé la clé, mais je ne savais pas comment changer le code.

À ce moment-là, je me suis souvenu de commentaires déjà lus : quelqu’un mentionnait qu’il fallait prêter attention à la continuité des variations des indicateurs. Oui, continuité ! C’est exactement ce à quoi je pensais.

Je suis retourné à l’assistant IA et cette fois j’ai fait une demande claire : il faut mettre en évidence la continuité de l’évolution de la valeur J. On ne peut pas se contenter de regarder la vitesse de changement d’un seul point, mais il faut regarder la tendance de changement sur plusieurs jours consécutifs.

La solution apportée par l’IA cette fois-ci a été révélatrice. Elle a repensé toute la logique de l’analyse de la valeur J :

1. Non seulement enregistrez la direction actuelle du changement, mais suivez également le nombre de jours consécutifs de changement
2. Ce n’est que lorsque la tendance change dans la même direction pendant plusieurs jours consécutifs qu’elle est considérée comme une tendance valide.
3. Après avoir confirmé la continuité, nous pouvons alors juger de la vitesse du changement.

La deuxième version améliorée du code de stratégie :

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

En constatant cette amélioration, j’ai été ravi de constater que « c’est bien ça ». Désormais, la variation de la valeur J n’est plus un point isolé, mais une tendance continue.

La surprise du deuxième backtest

Après avoir reçu le nouveau code, j’avais hâte de faire un autre backtest.

J’ai été un peu surpris par le résultat cette fois-ci. Même si on ne peut pas dire que ce soit une stratégie parfaite, elle est clairement bien meilleure que la première version :

• Il y a moins de faux signaux car l’exigence de continuité filtre beaucoup de bruit.
• Le taux de gain a été considérablement amélioré
• La logique de la stratégie est plus claire

En observant la courbe de profit du rapport de backtest, j’éprouve un profond sentiment d’accomplissement. Bien que ce ne soit pas une stratégie révolutionnaire, elle est née d’une idée et a été explorée étape par étape.

Expérience d’utilisation des outils

Cette exploration m’a donné une nouvelle compréhension des assistants IA et des plateformes quantitatives.

La valeur des assistants IA :

Je pensais auparavant que l’IA n’était qu’un outil auxiliaire d’intelligence artificielle, mais cette fois, j’ai découvert qu’elle est vraiment utile en trading quantitatif. Son principal intérêt n’est pas de remplacer la pensée humaine, mais de réduire considérablement la distance entre l’idée et le code.

1. Forte capacité de compréhension:J’ai simplement utilisé un langage très simple pour décrire une idée, et il peut être compris avec précision et transformé en une logique stratégique complète
2. Vitesse d’itération rapide:Lorsque je fais une demande d’amélioration, il peut rapidement localiser le problème et apporter une solution
3. Bonne qualité de code：Le code généré est non seulement exécutable, mais possède également une structure claire et des commentaires détaillés

Commodité de la plateforme quantitative : Je suis également impressionné par la fonction de backtesting de la plateforme Inventor. Auparavant, pour tester une stratégie, il fallait trouver des données historiques, créer un framework de backtesting et gérer divers détails techniques. Désormais, il suffit de coller le code, de définir les paramètres et de visualiser immédiatement les résultats.

Ce retour d’information instantané rend l’ensemble du processus d’exploration très fluide, et les idées, le code, la vérification et l’amélioration forment un cycle très rapide.

Quelques réflexions

Bien sûr, cette exploration m’a aussi fait réfléchir à quelques questions :

Limites de l’IA : Bien que l’IA ait été d’une grande aide, elle n’est pas omnipotente. Elle ne peut pas détecter seule les problèmes de la première version du code et a besoin de l’aide de personnes pour l’analyser et l’évaluer. De plus, la solution proposée par l’IA n’est peut-être pas optimale et doit être adaptée à la situation réelle.

Limites de la stratégie elle-même : Bien que cette stratégie soit performante en backtesting, elle n’est pas une solution miracle. Elle est généralement performante sur des marchés volatils, et les paramètres doivent être ajustés en fonction des différentes devises.

Le plus important est que, même si une stratégie affiche de bons résultats historiques, on ne peut pas présumer qu’elle le sera à l’avenir. Le marché évolue et les stratégies doivent être constamment ajustées.

Un bonus inattendu

Outre la stratégie elle-même, cette exploration a également donné lieu à des gains inattendus :

La compréhension du trading quantitatif a changé : Je pensais que le trading quantitatif avait un seuil d’accès élevé et nécessitait de solides compétences en programmation et de solides bases mathématiques. Cette expérience m’a fait prendre conscience que les idées et la logique sont plus importantes. Avec de bons outils, le seuil technique n’est pas aussi élevé qu’on le pensait.

Changement d’attitude envers l’apprentissage : Par le passé, lorsque je trouvais des idées intéressantes, je me disais toujours : « J’essaierai quand j’aurai le temps », mais c’était souvent en vain. Cette expérience m’a fait comprendre que les outils actuels facilitent l’expérimentation ; l’essentiel est d’avoir le courage d’agir.

La perspective sur l’échec a changé : Lorsque la première version de la stratégie n’a pas fonctionné, je n’ai pas abandonné immédiatement, mais j’ai analysé le problème. Ce processus m’a fait comprendre que l’échec n’est souvent pas une fin en soi, mais un indice pour trouver la bonne direction.

Plans ultérieurs

Cette stratégie est toujours présente dans mon code source et je l’utilise occasionnellement. Bien qu’elle ne soit pas parfaite, j’en suis plutôt satisfait après exploration.

Plus important encore, cette expérience m’a donné confiance. Il s’avère que la distance entre l’idée et la stratégie n’est pas aussi grande que je l’imaginais.

Ensuite, je voudrais poursuivre cette exploration :

• Accordez plus d’attention à certaines théories et idées commerciales intéressantes
• Essayez d’appliquer certains concepts d’autres domaines au trading
• Continuer à exploiter l’IA et les plateformes quantitatives pour valider rapidement les idées

Conseils aux autres

Si vous êtes également intéressé par le trading quantitatif, mes suggestions sont :

1. Ne vous laissez pas intimider par les barrières techniques:Les outils actuels sont déjà très puissants, ce qui compte c’est d’avoir des idées et de les exécuter
2. Commencez petit:Pas besoin de rechercher une stratégie parfaite, commencez à explorer avec des idées simples
3. Soyez courageux pour essayer et échouerIl est normal d’échouer du premier coup. L’essentiel est d’analyser le problème et d’apporter des améliorations continues.
4. Gardez une attitude d’apprentissage: Accordez plus d’attention aux différents points de vue et théories. L’inspiration vient souvent de sources inattendues.

Conclusion

Avec le recul, le point de départ de cette exploration n’était qu’un commentaire sur Bilibili, mais il m’a permis de vivre un processus complet de développement de stratégie quantitative.

À une époque où les connaissances et les outils sont à portée de main, il nous manque peut-être simplement une tentative courageuse. Que vous soyez novice en trading quantitatif ou trader expérimenté, vous pouvez partir d’une idée simple et voir où vous pouvez aller.

La prochaine stratégie intéressante pourrait être cachée dans un commentaire que vous venez de lire.

Avertissement : Ceci est un simple partage d’expérience d’exploration personnelle, et non un conseil en investissement. Le trading comporte des risques ; veuillez prendre vos décisions avec prudence.