
A estratégia de negociação quantitativa de otimização de flutuações de preços de diferenças de rede neural é um sistema de negociação de alta frequência baseado em uma rede neural artificial (ANN), projetado para otimização de prazos de 1 segundo. A estratégia usa a rede neural para analisar variações de preços de curto prazo, prever a direção dos preços por meio de algoritmos de transmissão para a frente e, em combinação com filtragem de taxa de flutuação e controle de tempo de sessão, para otimizar as decisões de negociação.
A estratégia usa uma arquitetura de rede neural de três camadas para processar dados de diferença de preços por meio de algoritmos de transmissão para a frente:
Camada de entrada (L0): Percentagem de diferença entre a recepção do OHLC4 atual ((Average High/Low) e a recepção do OHLC4 histórico no referencial de tempo (default 15s) como uma única entrada de neurônio.
Primeira camada oculta (L1): Contém 5 neurônios que usam a função de ativação binomial tanh para uma transformação não linear dos dados de entrada. Cada neurônio possui um peso pré-treinado para capturar um padrão específico de diferença de preço.
Segunda camada oculta (L2): Contém 33 neurônios, também usando a função de ativação tanh, para processar ainda mais a saída da primeira camada oculta através de uma matriz de pesos mais complexa.
Camada de saída (L3): Um único neurônio produz um sinal de previsão final, cujo valor é invertido para corrigir a direção do sinal.
A lógica de transação gira em torno do valor de saída da rede neural ((L3_0)):
A estratégia também implementa um mecanismo de filtragem triplo:
Previsão de alta precisãoA estrutura multicamadas de uma rede neural é capaz de capturar relações não-lineares complexas em movimentos de preços, o que é difícil de ser feito com indicadores técnicos tradicionais. Especialmente em ambientes de alta frequência, a estrutura pode identificar padrões de preços de curto prazo e fornecer sinais de entrada e saída mais precisos.
Excelente relação risco/retornoA estratégia alcançou um fator de lucro de 3.754, o que significa que o total de negócios lucrativos é 3.754 vezes maior que o total de negócios perdedores, o que é um excelente desempenho em uma estratégia quantitativa.
Espaço de otimização de parâmetros flexíveisA estratégia oferece vários parâmetros ajustáveis, incluindo o limiar de entrada/saída, a duração do período de arrefecimento, o período de referência e os requisitos de taxa de flutuação mínima, permitindo que os comerciantes otimizem de acordo com diferentes cenários de mercado e variedades de negociação.
Mecanismo de filtragem múltiplaA estratégia reduziu de forma eficaz as transações desnecessárias e os falsos sinais, aumentando a qualidade das transações, através da integração de um triplo filtro de períodos de arrefecimento, volatilidade e tempo de negociação.
Adaptação a um ambiente de alta frequência: Otimizado para um marco de tempo de 1 segundo, que permite aproveitar ao máximo as características de negociação de alta frequência para capturar oportunidades de lucro de flutuações de preços de curto prazo.
Implementação de baixa latência: Estrutura de código de estratégia clara e eficiente, a parte da rede neural usa pesos de pré-treinamento para calcular diretamente, sem a necessidade de treinamento em tempo real, garantindo a execução de baixa latência em ambientes de alta frequência.
Risco de sobreajusteOs modelos de redes neurais contêm uma grande quantidade de parâmetros de peso predefinidos, com risco de sobre-ajuste de dados históricos. Isso pode levar a uma estratégia de menor desempenho em negociações reais, especialmente quando as condições de mercado mudam significativamente. Os métodos de resposta incluem: retreinamento regular das redes neurais, verificação com dados de períodos de tempo mais longos e implementação de medidas sólidas de gerenciamento de risco.
Sensibilidade do parâmetro: A performance da estratégia é altamente dependente de várias configurações de parâmetros, como o limiar de entrada/saída, a duração do período de resfriamento, etc. Pequenas variações nos parâmetros podem causar grandes flutuações na performance da estratégia. É recomendável encontrar combinações de parâmetros estáveis por meio de varredura de parâmetros e teste de passo a passo, e evitar otimização excessiva.
Riscos de negociação de alta frequênciaEm um período de tempo de 1 segundo, os custos de transação (como os pontos de diferença e os pontos de deslizamento) podem afetar significativamente a lucratividade da estratégia. Estes custos devem ser plenamente considerados antes da negociação em campo e as condições reais de custos de transação devem ser simuladas na retrospectiva.
O desafio da tecnologiaA estratégia de alta frequência exige que o sistema de negociação tenha uma latência extremamente baixa e alta confiabilidade. Qualquer atraso na rede, atraso no dados ou atraso na execução pode levar à falha da estratégia.
Risco de flutuação do mercadoEm condições de mercado extremas (por exemplo, notícias repentinas ou esgotamento de liquidez), o modelo de rede neural pode não ser capaz de prever com precisão a movimentação dos preços, resultando em grandes perdas. É recomendável definir medidas de parada de perdas e limites de perda máxima diária e suspender a operação da estratégia durante oscilações extremas.
Arquitetura de redes neurais otimizada:
Mecanismo de ajuste de parâmetros dinâmicos:
Quadro de previsão integrado:
Gestão de Riscos reforçada:
Aprendizagem e adaptação em tempo real:
A estratégia de negociação quantitativa de otimização de fluctuações de preços de diferenças de rede neural representa uma prática de vanguarda da negociação quantitativa moderna, aplicando com sucesso a tecnologia de rede neural artificial no campo da negociação de alta frequência. Através de uma estrutura de rede neural multicamadas cuidadosamente projetada, a estratégia é capaz de capturar padrões sutis em variações de preços de curto prazo e melhorar a qualidade de negociação por meio de múltiplos mecanismos de filtragem.
O fator de lucro de 3.754 demonstra o excelente desempenho da estratégia em um ambiente de teste, mas a aplicação prática ainda precisa considerar cuidadosamente os riscos específicos de superalimento, sensibilidade de parâmetros e negociação de alta frequência. A estratégia tem o potencial de manter a competitividade a longo prazo no setor de negociação quantitativa altamente competitiva, através da otimização contínua da arquitetura da rede neural, da realização de ajustes de parâmetros dinâmicos e do aumento do gerenciamento de riscos.
O fator de sucesso chave da estratégia reside na combinação de técnicas de redes neurais complexas com lógica de negociação prática, tanto com a capacidade preditiva de aprendizado de máquina como com a viabilidade de negociações reais. Para os comerciantes de quantificação experientes, isso oferece uma estrutura escalonável que pode ser ainda mais personalizada e otimizada de acordo com diferentes mercados e preferências de risco pessoais.
/*backtest
start: 2024-06-23 00:00:00
end: 2025-06-21 08:00:00
period: 2h
basePeriod: 2h
exchanges: [{"eid":"Futures_Binance","currency":"ETH_USDT"}]
*/
//@version=5
strategy("ANN Strategy v2 (Optimized for 1s)", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=100)
// === INPUTS ===
entryThreshold = input.float(0.003, title="Entry Threshold")
exitThreshold = input.float(0.001, title="Exit Threshold")
cooldownBars = input.int(60, title="Cooldown (bars)") // 60 seconds cooldown
timeframe = input.timeframe("1", title="Reference Timeframe") // 1-minute diff reference
minVolatility = input.float(0.02, title="Min ATR (Volatility Filter)")
useSession = input.bool(true, title="Use Session Filter")
// === UTILITY FUNCTIONS ===
getDiff() =>
prev = request.security(syminfo.tickerid, timeframe, ohlc4[1])
now = ohlc4
(now - prev) / prev
linear(v) => v
tanh(v) => (math.exp(v) - math.exp(-v)) / (math.exp(v) + math.exp(-v))
// === ANN FORWARD PROPAGATION ===
l0_0 = linear(getDiff())
l1 = array.new_float()
array.push(l1, tanh(l0_0 * 0.8446488687))
array.push(l1, tanh(l0_0 * -0.5674069006))
array.push(l1, tanh(l0_0 * 0.8676766445))
array.push(l1, tanh(l0_0 * 0.5200611473))
array.push(l1, tanh(l0_0 * -0.2215499554))
// === Layer 2 weights ===
w2 = array.from( 0.3341657935, -2.0060003664, 0.8606354375, 0.9184846912, -0.8531172267, -0.0394076437, -0.4720374911, 0.2900968524, 1.0653326022, 0.3000188806, -0.559307785, -0.9353655177, 1.2133832962, 0.1952686024, 0.8552068166, -0.4293220754, 0.8484259409, -0.7154087313, 0.1102971055, 0.2279392724, 0.9111779155, 0.2801691115, 0.0039982713, -0.5648257117, 0.3281705155, -0.2963954503, 0.4046532178, 0.2460580977, 0.6608675819, -0.8732022547, 0.8810811932, 0.6903706878, -0.5953059103, -0.3084040686, -0.4038498853, -0.5687101164, 0.2736758588, -0.2217360382, 0.8742950972, 0.2997583987, 0.0708459913, 0.8221730616, -0.7213265567, -0.3810462836, 0.0503867753, 0.4880140595, 0.9466627196, 1.0163097961, -0.9500386514, -0.6341709382, 1.3402207103, 0.0013395288, 3.4813009133, -0.8636814677, 41.3171047132, 1.2388217292, -0.6520886912, 0.3508321737, 0.6640560714, 1.5936220597, -0.1800525171, -0.2620989752, 0.056675277, -0.5045395315, 0.2732553554, -0.7776331454, 0.1895231137, 0.5384918862, 0.093711904, -0.3725627758, -0.3181583022, 0.2467979854, 0.4341718676, -0.7277619935, 0.1799381758, -0.5558227731, 0.3666152536, 0.1538243225, -0.8915928174, -0.7659355684, 0.6111516061, -0.5459495224, -0.5724238425, -0.8553500765, -0.8696190472, 0.6843667454, 0.408652181, -0.8830470112, -0.8602324935, 0.1135462621, -0.1569048216, -1.4643247888, 0.5557152813, 1.0482791924, 1.4523116833, 0.5207514017, -0.2734444192, -0.3328660936, -0.7941515963, -0.3536051491, -0.4097807954, 0.3198619826, 0.461681627, -0.1135575498, 0.7103339851, -0.8725014237, -1.0312091401, 0.2267643037, -0.6814258121, 0.7524828703, -0.3986855003, 0.4962556631, -0.7330224516, 0.7355772164, 0.3180141739, -1.083080442, 1.8752543187, 0.3623326265, -0.348145191, 0.1977935038, -0.0291290625, 0.0612906199, 0.1219696687, -1.0273685429, 0.0872219768, 0.931791094, -0.313753684, -0.3028724837, 0.7387076712, 0.3806140391, 0.2630619402, -1.9827996702, -0.7741413496, 0.1262957444, 0.2248777886, -0.2666322362, -1.124654664, 0.7288282621, -0.1384289204, 0.2395966188, 0.6611845175, 0.0466048937, -0.1980999993, 0.8152350927, 0.0032723211, -0.3150344751, 0.1391754608, 0.5462816249, -0.7952302364, -0.7520712378, -0.0576916066, 0.3678415302, 0.6802537378, 1.1437036331, -0.8637405666, 0.7016273068, 0.3978601709, 0.3157049654, -0.2528455662, -0.8614146703, 1.1741126834, -1.4046408959, 1.2914477803, 0.9904052964, -0.6980155826)
l2 = array.new_float()
for i = 0 to 32
sum = 0.0
for j = 0 to 4
weight = array.get(w2, i * 5 + j)
sum += weight * array.get(l1, j)
array.push(l2, tanh(sum))
// === Output layer weights ===
weights_out = array.from( -0.1366382003, 0.8161960822, -0.9458773183, 0.4692969576, 0.0126710629, -0.0403001012, -0.0116244898, -0.4874816289, -0.6392241448, -0.410338398, -0.1181027081, 0.1075562037, -0.5948728252, 0.5593677345, -0.3642935247, -0.2867603217, 0.142250271, -0.0535698019, -0.034007685, -0.3594532426, 0.2551095195, 0.4214344983, 0.8941621336, 0.6283377368, -0.7138020667, -0.1426738249, 0.172671223, 0.0714824385, -0.3268182144, -0.0078989755, -0.2032828145, -0.0260631534, 0.4918037012)
sum_out = 0.0
for i = 0 to array.size(l2) - 1
sum_out += array.get(weights_out, i) * array.get(l2, i)
// === Final ANN output (inverted for signal correction) ===
l3_0 = -tanh(sum_out)
// === TRADE FILTERS ===
volatility = ta.atr(14)
isVolOkay = volatility > minVolatility
isSession = (hour >= 9 and hour < 16) // Adjust to your market hours
sessionOkay = useSession ? isSession : true
// === SIGNAL LOGIC ===
var string activeTrade = "none"
var int lastTradeBar = na
canTrade = (na(lastTradeBar) or (bar_index - lastTradeBar > cooldownBars)) and isVolOkay and sessionOkay
enterLong = l3_0 > entryThreshold and activeTrade != "long" and canTrade
exitLong = l3_0 < exitThreshold and activeTrade == "long"
enterShort = l3_0 < -entryThreshold and activeTrade != "short" and canTrade
exitShort = l3_0 > -exitThreshold and activeTrade == "short"
// === STRATEGY EXECUTION ===
if barstate.isrealtime
if enterLong
strategy.entry("Long", strategy.short)
activeTrade := "long"
lastTradeBar := bar_index
if exitLong
strategy.close("Long")
activeTrade := "none"
if enterShort
strategy.entry("Short", strategy.long)
activeTrade := "short"
lastTradeBar := bar_index
if exitShort
strategy.close("Short")
activeTrade := "none"
// === PLOTTING ===
bgcolor(activeTrade == "long" ? color.new(color.green, 85) : activeTrade == "short" ? color.new(color.red, 85) : na)
plot(l3_0, title="ANN Output (Inverted)", color=color.aqua, linewidth=2)