O começo de tudo

Tenho trabalhado com negociação quantitativa há algum tempo. Para ser sincero, na maioria das vezes, apenas leio as estratégias compartilhadas por outros e tento modificar os parâmetros. Não tenho muitas oportunidades de realmente começar uma estratégia do zero, principalmente porque não tenho boas ideias, e a distância entre as ideias e a programação parece muito grande.

Eu estava livre há algum tempo, então comecei a navegar pela estação B novamente. Por acaso, vi a transmissão ao vivo do Brother Z. Eu estava assistindo casualmente, mas não esperava que me desse uma inspiração inesperada.

Esse resumo incrível

Quando o irmão Z estava falando sobre o indicador KDJ, um internauta na área de comentários postou uma frase que achei particularmente interessante:

Se o preço cair ligeiramente, o gancho cai rapidamente, o que pode indicar uma tendência de alta no futuro. Se o preço cair acentuadamente, o gancho cai lentamente, o que pode indicar uma nova queda no futuro. Se o preço subir ligeiramente, o sulco cresce rapidamente, o que pode indicar uma tendência de baixa no futuro. Se o preço subir acentuadamente, o gancho cresce lentamente, o que pode indicar uma nova alta no futuro.

Fiquei perplexo na hora. Este resumo é tão esclarecedor! Embora seja apenas uma frase, parece explicar claramente as regras mutáveis ​​do valor J do KDJ.

Pensei comigo mesmo: “O irmão Z está no mercado de ações”, mas essa lógica também deveria se aplicar às criptomoedas, certo? Quanto mais eu pensava nisso, mais fazia sentido. A magnitude das mudanças de preço e a velocidade das reações dos indicadores, essas duas dimensões combinadas para avaliar a tendência subsequente, pareciam muito lógicas. Além disso, o mercado de criptomoedas opera 24 horas por dia e a volatilidade é maior, então talvez essa teoria tenha um desempenho melhor.

Naquele momento, fiquei um pouco animado e senti que havia encontrado uma direção para explorar. Mas então me preocupei novamente: como transformar essa ideia em código? No passado, quando me deparava com uma situação dessas, eu ou pensava a respeito ou deixava de lado e fazia quando tinha tempo.

Decidi tentar

Mas desta vez é diferente. Lembrei que a Plataforma Inventor tem um assistente de IA, então queria tentar ver se conseguia “traduzir” essa ideia diretamente para o código.

Com uma atitude de experimentar, abri o assistente de IA da Plataforma Inventor, inseri a ideia literalmente e acrescentei: Esta é uma teoria aplicada a ações e quero testá-la em criptomoedas.

Eu não esperava que a IA entendesse tão rápido e gerasse um conjunto completo de códigos de estratégia para mim tão rapidamente. Naquele momento, fiquei bastante surpreso e pensei: a IA é tão poderosa agora?

A primeira versão do código de estratégia:

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

A emoção e a decepção da primeira vez

Depois de obter o código, a primeira coisa que fiz foi verificar se ele funcionava. O editor da Plataforma Inventor indicou que não havia erros de sintaxe, o que me deixou aliviado.

Então chega o momento mais emocionante: o backtesting online. Na página do Assistente de IA do Inventor, você pode realizar o backtesting online em tempo real no canto inferior direito da página gerada. Selecione a moeda de backtesting BTC, defina o intervalo de tempo e clique no botão de backtesting online.

Depois que os resultados saíram, fiquei um pouco confuso. O código rodou e a lógica parecia correta, mas os resultados do backtest não foram ideais. Embora tenha havido momentos em que obtive lucro, a taxa geral de acertos não foi alta, e muitas vezes sofri perdas consecutivas.

Parecia que um avião que, em teoria, deveria ser capaz de voar, foi construído, mas não conseguiu. Fiquei um pouco decepcionado, mas não estava disposto a desistir.

Caindo em pensamentos

Se a teoria faz sentido e o código funciona, qual é o problema?

Comecei a estudar a lógica do código cuidadosamente. Descobri que o código escrito pela IA julga principalmente “rápido” e “lento” calculando a velocidade de mudança do 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

À primeira vista, parece que não há nada de errado, mas sempre sinto que há algo errado.

Depois de pensar sobre isso, de repente percebi um problema: esse cálculo só olha para a velocidade da mudança em um determinado momento, mas não leva em consideração a mudança deContinuidade。

Por exemplo, o valor de J pode mudar rapidamente em um determinado dia, mas é apenas um fenômeno passageiro e retorna ao normal no dia seguinte. Nesse caso, julgar pela velocidade de um único ponto pode não ser preciso.

A teoria original diz “desligar rapidamente” e “desligar lentamente”. “Rápido” e “lento” devem se referir a um processo contínuo, e não ao estado em um determinado ponto.

Encontrando um avanço

Depois de perceber esse problema, fiquei um pouco animado novamente. Senti que tinha encontrado a chave, mas não sabia como alterar o código.

Nesse momento, lembrei-me de alguns comentários que vi antes. Alguém mencionou que deveríamos prestar atenção à continuidade das mudanças nos indicadores. Sim, continuidade! Era exatamente nisso que eu estava pensando.

Voltei ao assistente de IA e desta vez fiz um pedido claro: devemos destacar a continuidade da mudança no valor de J. Não podemos apenas olhar para a velocidade de mudança de um único ponto, mas devemos olhar para a tendência de mudança ao longo de vários dias consecutivos.

A solução oferecida pela IA desta vez foi reveladora. Ela redesenhou toda a lógica da análise do valor J:

1. Não apenas registre a direção atual da mudança, mas também acompanhe o número de dias consecutivos de mudança
2. Somente quando a tendência muda na mesma direção por vários dias consecutivos ela é considerada uma tendência válida.
3. Depois de confirmar a continuidade, podemos então avaliar a velocidade da mudança.

A segunda versão melhorada do código de estratégia:

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

Ao ver essa melhora, fiquei animado e pensei: “Essa é a sensação”. Agora, a mudança no valor de J não é mais um ponto isolado, mas uma tendência contínua.

A surpresa do segundo backtest

Depois de obter o novo código, mal pude esperar para fazer outro backtest.

Fiquei um pouco surpreso com o resultado desta vez. Embora não se possa dizer que seja uma estratégia perfeita, é obviamente muito melhor do que a primeira versão:

• Há menos sinais falsos porque a exigência de continuidade filtra muito ruído.
• A taxa de vitórias foi significativamente melhorada
• A lógica da estratégia é mais clara

Observando a curva de lucro no relatório de backtest, sinto uma forte sensação de realização. Embora não seja uma estratégia revolucionária, ela começou com uma ideia e foi explorada passo a passo.

Experiência de uso de ferramentas

Essa exploração me deu uma nova compreensão de assistentes de IA e plataformas quantitativas.

O valor dos assistentes de IA:

Eu costumava pensar que a IA era apenas uma ferramenta auxiliar de inteligência fraca, mas desta vez descobri que ela é realmente útil em negociações quantitativas. O maior valor não é substituir o pensamento humano, mas encurtar significativamente a distância entre a ideia e o código.

1. Forte capacidade de compreensão:Acabei de descrever uma ideia em linguagem muito simples, e ela pode ser compreendida com precisão e transformada em uma lógica estratégica completa
2. Velocidade de iteração rápida:Quando faço uma solicitação de melhoria, ele pode localizar rapidamente o problema e fornecer uma solução
3. Boa qualidade de código：O código gerado não é apenas executável, mas também possui uma estrutura clara e comentários detalhados

Conveniência da plataforma quantitativa: Também fiquei impressionado com a função de backtesting da plataforma Inventor. Antigamente, para testar uma estratégia, era preciso encontrar dados históricos, escrever uma estrutura de backtesting e lidar com vários detalhes técnicos. Agora, basta colar o código, definir os parâmetros e ver os resultados imediatamente.

Esse feedback instantâneo torna todo o processo de exploração muito tranquilo, e ideias, código, verificação e melhoria formam um ciclo muito rápido.

Algumas reflexões

Claro que essa exploração também me fez pensar em algumas questões:

Limitações da IA: Embora a IA tenha ajudado muito, ela não é onipotente, afinal. A IA não consegue encontrar os problemas da primeira versão do código sozinha e ainda precisa de pessoas para analisar e julgar. Além disso, a solução dada pela IA pode não ser a melhor e precisa ser ajustada de acordo com a situação real.

Limitações da própria estratégia: Embora essa estratégia tenha um bom desempenho em backtests, ela não é uma panaceia. Ela geralmente tem um bom desempenho em mercados voláteis, e os parâmetros precisam ser ajustados de acordo com as diferentes moedas.

O mais importante é que, só porque uma estratégia tem um bom desempenho em dados históricos, não se pode presumir que será eficaz no futuro. O mercado está mudando e as estratégias precisam ser constantemente ajustadas.

Um bônus inesperado

Além da estratégia em si, essa exploração também rendeu alguns ganhos inesperados:

A compreensão da negociação quantitativa mudou: Eu costumava pensar que o limiar para negociação quantitativa era muito alto, exigindo fortes habilidades de programação e base matemática. Essa experiência me fez sentir que ideias e lógica são mais importantes. Com boas ferramentas, o limiar técnico não é tão alto quanto se imaginava.

Mudança de atitude em relação à aprendizagem: No passado, quando me deparava com ideias interessantes, sempre pensava: “Vou tentar quando tiver tempo”, mas muitas vezes acabava em vão. Essa experiência me fez perceber que as ferramentas atuais tornaram mais fácil “tentar”; o segredo é ter coragem para agir.

A perspectiva sobre o fracasso mudou: Quando a primeira versão da estratégia não funcionou bem, não desisti imediatamente, mas analisei o problema. Esse processo me fez perceber que o fracasso muitas vezes não é o fim, mas uma pista para encontrar a direção certa.

Planos subsequentes

Essa estratégia ainda está na minha base de código e eu a utilizo ocasionalmente. Embora não seja uma estratégia perfeita, estou bastante satisfeito com ela após a exploração.

Mais importante ainda, essa experiência me deu confiança. Acontece que a distância entre a ideia e a estratégia não é tão grande quanto eu imaginava.

Em seguida, gostaria de continuar esta exploração:

• Preste mais atenção a algumas teorias e ideias interessantes de negociação
• Tente aplicar alguns conceitos de outras áreas à negociação
• Continue a alavancar a IA e as plataformas quantitativas para validar ideias rapidamente

Conselhos para outros

Se você também estiver interessado em negociação quantitativa, minhas sugestões são:

1. Não se deixe intimidar pelas barreiras técnicas:As ferramentas atuais já são muito poderosas, o que importa é ter ideias e execução
2. Comece pequeno: Não há necessidade de seguir uma estratégia perfeita, comece a explorar com ideias simples
3. Seja corajoso para tentar e falhar: É normal falhar na primeira vez. O segredo é analisar o problema e fazer melhorias contínuas.
4. Mantenha uma atitude de aprendizagem: Preste mais atenção a diferentes pontos de vista e teorias. A inspiração geralmente vem de lugares inesperados.

Conclusão

Olhando para trás, o ponto de partida desta exploração foi apenas um comentário sobre Bilibili, mas me permitiu vivenciar um processo completo de desenvolvimento de estratégia quantitativa.

Nesta era em que o conhecimento e as ferramentas estão ao nosso alcance, talvez nos falte realmente uma tentativa corajosa. Seja você um novato em quantitativa ou um trader experiente, você pode tentar começar com uma ideia simples e ver aonde consegue chegar.

A próxima estratégia interessante pode estar escondida em um comentário que você acabou de ler.

Aviso: Este é apenas um compartilhamento de experiência pessoal de exploração, não um conselho de investimento. Negociar é arriscado, por isso tome decisões com cuidado.