El comienzo de todo

Llevo un tiempo haciendo trading cuantitativo. Siendo sincero, la mayoría de las veces simplemente leo las estrategias compartidas por otros y luego intento modificar los parámetros. No tengo muchas oportunidades de empezar una estrategia desde cero, principalmente porque no tengo buenas ideas, y el camino entre las ideas y el código parece bastante largo.

Hace un rato tuve tiempo libre, así que volví a navegar por la estación B. Vi por casualidad la transmisión en vivo del Hermano Z. La estaba viendo casualmente, pero no esperaba que me diera una inspiración inesperada.

Ese increíble resumen

Cuando Brother Z estaba hablando sobre el indicador KDJ, un internauta en el área de comentarios publicó una oración que me pareció particularmente interesante:

Si el precio baja ligeramente, el gancho baja rápidamente, lo que puede indicar una tendencia alcista futura. Si el precio baja bruscamente, el gancho baja lentamente, lo que puede indicar una nueva caída futura. Si el precio sube ligeramente, la ranura crece rápidamente, lo que puede indicar una tendencia bajista futura. Si el precio sube bruscamente, el gancho crece lentamente, lo que puede indicar una nueva subida futura.

Me quedé atónito en ese momento. ¡Este resumen es muy esclarecedor! Aunque solo es una frase, parece explicar claramente las reglas cambiantes del valor J de KDJ.

Pensé: «El hermano Z está en la bolsa, pero esta lógica también debería aplicarse a las criptomonedas, ¿no?». Cuanto más lo pensaba, más sentido tenía. La magnitud de los cambios de precio y la velocidad de las reacciones de los indicadores, estas dos dimensiones combinadas para juzgar la tendencia posterior, parecían muy lógicas. Además, el mercado de criptomonedas opera las 24 horas del día y la volatilidad es mayor, así que quizás esta teoría sea más válida.

En ese momento, me emocioné un poco y sentí que había encontrado un camino que explorar. Pero luego me preocupé de nuevo: ¿cómo puedo convertir esta idea en código? Antes, cuando me encontraba en una situación así, lo pensaba o lo dejaba de lado y lo hacía cuando tenía tiempo.

Decidí darle una oportunidad.

Pero esta vez es diferente. Recordé que la Plataforma Inventor tiene un asistente de IA, así que quise ver si podía traducir esta idea directamente al código.

Con actitud de probarlo, abrí el asistente de inteligencia artificial de la Plataforma Inventor, ingresé la idea textualmente y agregué: Esta es una teoría aplicada a las acciones y quiero probarla en las criptomonedas.

No esperaba que la IA comprendiera tan rápido y generara un conjunto completo de códigos de estrategia para mí. En ese momento, me sorprendí bastante y pensé: ¿Es tan poderosa la IA ahora?

La primera versión del código de estrategia:

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

La emoción y la decepción de la primera vez

Tras obtener el código, lo primero que hice fue comprobar si funcionaba. El editor de la plataforma Inventor indicó que no había errores de sintaxis, lo cual me tranquilizó.

Llega el momento más emocionante: el backtesting online. En la página del Asistente de IA de Inventor, puedes realizar backtesting online en tiempo real en la esquina inferior derecha de la página generada. Selecciona BTC como moneda de backtesting, define el intervalo de tiempo y haz clic en el botón de backtesting online.

Tras conocer los resultados, me sentí un poco confundido. El código funcionó y la lógica parecía correcta, pero los resultados del backtesting no fueron ideales. Aunque hubo momentos en que obtuve ganancias, la tasa de ganancias general no fue alta y a menudo sufrí pérdidas consecutivas.

Parecía que se había construido un avión que, en teoría, debería poder volar, pero que, al final, no pudo. Me sentí un poco decepcionado, pero no estaba dispuesto a rendirme.

Cayendo en pensamientos

Si la teoría tiene sentido y el código funciona, ¿cuál es el problema?

Comencé a estudiar la lógica del código con detenimiento. Descubrí que el código escrito por IA juzga principalmente la velocidad de cambio del valor 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

A primera vista no parece que haya nada malo, pero siempre tengo la sensación de que algo anda mal.

Después de pensarlo, de repente me di cuenta de un problema: este cálculo solo considera la velocidad del cambio en un momento determinado, pero no tiene en cuenta el cambio deContinuidad。

Por ejemplo, el valor J puede cambiar rápidamente un día, pero es solo un fenómeno pasajero y vuelve a la normalidad al día siguiente. En este caso, juzgar por la velocidad de un solo punto puede no ser preciso.

La teoría original dice “desengancharse rápidamente” y “desengancharse lentamente”. “Rápido” y “lento” deberían referirse a un proceso continuo, no al estado en un punto determinado.

Encontrar un avance

Tras darme cuenta del problema, me emocioné de nuevo. Sentí que había encontrado la clave, pero no sabía cómo cambiar el código.

En ese momento, recordé algunos comentarios que vi antes. Alguien mencionó que deberíamos prestar atención a la continuidad de los cambios en los indicadores. ¡Sí, continuidad! Eso es exactamente lo que estaba pensando.

Regresé al asistente de IA y esta vez le hice una solicitud clara: debemos resaltar la continuidad del cambio en el valor J. No podemos simplemente mirar la velocidad de cambio de un solo punto, sino que debemos mirar la tendencia de cambio durante varios días consecutivos.

La solución que proporcionó la IA en esta ocasión fue reveladora. Rediseñó por completo la lógica del análisis del valor J:

1. No solo registra la dirección actual del cambio, sino que también rastrea el número de días consecutivos de cambio.
2. Sólo cuando la tendencia cambia en la misma dirección durante varios días consecutivos se considera una tendencia válida.
3. Después de confirmar la continuidad, podemos juzgar la velocidad del cambio.

La segunda versión mejorada del código de estrategia:

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

Al ver esta mejora, me emocioné al pensar que “esta es la sensación”. Ahora, el cambio en el valor J ya no es un punto aislado, sino una tendencia continua.

La sorpresa del segundo backtest

Después de obtener el nuevo código, no podía esperar para hacer otra prueba retrospectiva.

Esta vez me sorprendió un poco el resultado. Aunque no se puede decir que sea una estrategia perfecta, es claramente mucho mejor que la primera versión:

• Hay menos señales falsas porque el requisito de continuidad filtra mucho ruido.
• La tasa de ganancias se ha mejorado significativamente
• La lógica de la estrategia es más clara.

Al observar la curva de ganancias en el informe de backtest, siento una gran sensación de logro. Aunque no es una estrategia revolucionaria, empezó con una idea y se exploró paso a paso.

Experiencia en el uso de herramientas

Esta exploración me proporcionó una nueva comprensión de los asistentes de IA y las plataformas cuantitativas.

El valor de los asistentes de IA:

Solía ​​pensar que la IA era solo una herramienta auxiliar de inteligencia débil, pero esta vez descubrí que es realmente útil en el trading cuantitativo. Su mayor valor no reside en reemplazar el pensamiento humano, sino en acortar considerablemente la distancia entre la idea y el código.

1. Fuerte capacidad de comprensión:Simplemente utilicé un lenguaje muy simple para describir una idea, y se puede entender con precisión y transformar en una lógica estratégica completa.
2. Velocidad de iteración rápida:Cuando hago una solicitud de mejora, puede localizar rápidamente el problema y proporcionar una solución.
3. Buena calidad del código：El código generado no solo es ejecutable, sino que también tiene una estructura clara y comentarios detallados.

Conveniencia de la plataforma cuantitativa: También me impresionó la función de backtesting de la plataforma Inventor. Antes, para realizar un backtesting de una estrategia, era necesario buscar datos históricos, desarrollar un marco de backtesting y abordar diversos detalles técnicos. Ahora solo hay que pegar el código, configurar los parámetros y ver los resultados al instante.

Esta retroalimentación instantánea hace que todo el proceso de exploración sea muy fluido, y las ideas, el código, la verificación y la mejora forman un ciclo muy rápido.

Algunas reflexiones

Por supuesto, esta exploración también me hizo pensar en algunas preguntas:

Limitaciones de la IA: Aunque la IA ha sido de gran ayuda, no es omnipotente. La IA no puede detectar los problemas de la primera versión del código por sí sola, y aún necesita que las personas la analicen y juzguen. Además, la solución que ofrece la IA puede no ser la mejor, y debe ajustarse a la situación real.

Limitaciones de la propia estrategia: Si bien esta estrategia funciona bien en backtesting, no es la panacea. Generalmente, funciona bien en mercados volátiles, y los parámetros deben ajustarse según las diferentes divisas.

Lo más importante es que, aunque una estrategia tenga un buen rendimiento en datos históricos, no se puede asumir que será efectiva en el futuro. El mercado está en constante evolución y las estrategias deben ajustarse constantemente.

Un bono inesperado

Además de la estrategia en sí, esta exploración también produjo algunas ganancias inesperadas:

La comprensión del comercio cuantitativo ha cambiado: Solía ​​pensar que el umbral para el trading cuantitativo era muy alto y requería sólidos conocimientos de programación y bases matemáticas. Esta experiencia me hizo comprender que las ideas y la lógica son más importantes. Con buenas herramientas, el umbral técnico no es tan alto como imaginaba.

Cambio de actitud hacia el aprendizaje: Antes, cuando encontraba ideas interesantes, siempre pensaba: “Lo intentaré cuando tenga tiempo”, pero a menudo era en vano. Esta experiencia me hizo darme cuenta de que las herramientas actuales facilitan el “intentar”. La clave está en tener la valentía de actuar.

La perspectiva sobre el fracaso ha cambiado: Cuando la primera versión de la estrategia no funcionó bien, no me rendí de inmediato, sino que analicé el problema. Este proceso me hizo comprender que el fracaso a menudo no es el final, sino una pista para encontrar el camino correcto.

Planes posteriores

Esta estrategia aún está en mi código y la uso ocasionalmente. Aunque no es perfecta, estoy bastante satisfecho con ella tras explorarla.

Y lo más importante, esta experiencia me dio confianza. Resulta que la distancia entre la idea y la estrategia no es tan grande como imaginaba.

A continuación me gustaría continuar con esta exploración:

• Preste más atención a algunas teorías e ideas comerciales interesantes.
• Intente aplicar algunos conceptos de otros campos al trading.
• Seguir aprovechando la IA y las plataformas cuantitativas para validar ideas rápidamente

Consejos para otros

Si también te interesa el trading cuantitativo, mis sugerencias son:

1. No te dejes intimidar por las barreras técnicas:Las herramientas actuales ya son muy potentes, lo que importa es tener ideas y ejecución.
2. Empieza poco a poco:No es necesario seguir una estrategia perfecta, comience a explorar con ideas simples.
3. Sé valiente para intentarlo y fracasarEs normal fallar la primera vez. La clave está en analizar el problema y realizar mejoras continuas.
4. Mantén una actitud de aprendizajePresta más atención a diferentes puntos de vista y teorías. La inspiración suele surgir de lugares inesperados.

Conclusión

Mirando hacia atrás, el punto de partida de esta exploración fue sólo un comentario sobre Bilibili, pero me permitió experimentar un proceso completo de desarrollo de una estrategia cuantitativa.

En esta era donde el conocimiento y las herramientas están al alcance de la mano, quizás simplemente nos falte la valentía. Tanto si eres un principiante en el trading cuantitativo como un trader experimentado, puedes empezar con una idea sencilla y ver hasta dónde puedes llegar.

La siguiente estrategia interesante podría estar oculta en un comentario que acabas de leer.

Descargo de responsabilidad: Esto es solo una experiencia de exploración personal, no un consejo de inversión. Operar es arriesgado, así que tome decisiones con cuidado.