
La stratégie de négociation quantifiée d’optimisation des fluctuations de prix des différences de réseau neuronal est un système de négociation à haute fréquence basé sur un réseau de neurones artificiels (ANN) conçu pour l’optimisation des délais de 1 seconde. La stratégie utilise les réseaux de neurones pour analyser les variations de prix à court terme, prédire la direction des prix grâce à des algorithmes de propagation vers l’avant et optimiser les décisions de négociation en combinant le filtrage de la volatilité et le contrôle de la durée de la session.
La stratégie utilise une architecture de réseau neuronal à trois niveaux pour traiter les données sur les écarts de prix via des algorithmes de propagation vers l’avant:
La couche d’entrée (L0): pourcentage de différence entre la réception de l’OHLC4 actuel (< la valeur moyenne de l’ouverture et de l’ouverture) et la réception de l’OHLC4 historique (< 15 secondes par défaut) en tant que neurone d’entrée unique.
Première couche cachée (L1): Contient 5 neurones qui utilisent la fonction d’activation de la double courbe orthogonale (tanh) pour effectuer une transformation non linéaire des données d’entrée. Chaque neurone est équipé d’un poids pré-entraîné pour capturer un modèle spécifique de différence de prix.
Deuxième couche cachée (L2): contient 33 neurones, utilise également la fonction d’activation tanh, pour traiter plus en détail les sorties de la première couche cachée via une matrice de poids plus complexe.
Couche de sortie (L3): Un seul neurone émet un signal prédictif final dont la valeur est inversée pour modifier la direction du signal.
La logique de transaction s’articule autour de la valeur de sortie du réseau de neurones ((L3_0)):
La stratégie implique également un triple mécanisme de filtration:
Prévisions de haute précision: La structure multicouche d’un réseau de neurones est capable de capturer des relations non linéaires complexes dans les mouvements de prix, ce que les indicateurs techniques traditionnels ont du mal à réaliser. En particulier dans des environnements à haute fréquence, la structure peut identifier des modèles de prix à court terme et fournir des signaux d’entrée et de sortie plus précis.
Un excellent rapport risque/rendement: La stratégie a réalisé un facteur de gain de 3.754, ce qui signifie que le nombre total de transactions rentables est 3.754 fois supérieur au nombre total de transactions non rentables, ce qui est une très bonne performance dans une stratégie quantifiée.
Espace d’optimisation de paramètres souple: La stratégie fournit plusieurs paramètres réglables, y compris les seuils d’entrée/sortie, la longueur de la période de refroidissement, le cadre de temps de référence et les exigences de taux de volatilité minimale, permettant aux traders d’optimiser en fonction des différentes conditions du marché et des variétés de transactions.
Mécanisme de filtrage multipleLa stratégie réduit efficacement les transactions inutiles et les faux signaux, et améliore la qualité des transactions en intégrant un triple filtrage des périodes de refroidissement, de la volatilité et des heures de négociation.
Adaptation à un environnement de trading à haute fréquence: optimisé pour un temps de 1 seconde, permettant de tirer le meilleur parti des caractéristiques des transactions à haute fréquence et de saisir les opportunités de profit des fluctuations de prix à court terme.
Mise en œuvre à faible délai: Structure de code stratégique claire et efficace, partie du réseau neuronal utilisant le calcul direct des poids de pré-entraînement, sans entraînement en temps réel, assurant une exécution à faible latence dans un environnement à haute fréquence.
Le risque d’une suradaptationLes modèles de réseaux neuronaux contiennent un grand nombre de paramètres de poids prédéfinis et présentent un risque de suradaptation aux données historiques. Cela peut entraîner une mauvaise performance de la stratégie dans les transactions en direct, en particulier lorsque les conditions du marché changent de manière significative. Les mesures de réponse comprennent: rééducation régulière des réseaux neuronaux, validation avec des données de plus longues périodes de temps et mise en œuvre de solides mesures de gestion des risques.
Paramètre Sensibilité: La performance d’une stratégie dépend fortement de plusieurs paramètres tels que le seuil d’entrée/sortie, la longueur du temps de refroidissement, etc. Des variations mineures des paramètres peuvent entraîner des fluctuations importantes de la performance de la stratégie. Il est recommandé de trouver une combinaison de paramètres stable par le biais d’une analyse des paramètres et d’un test par étapes, et d’éviter une optimisation excessive.
Risques liés aux transactions à haute fréquence: Sur une période de temps de 1 seconde, les coûts de transaction (comme les écarts et les points de glissement) peuvent avoir un impact significatif sur la rentabilité de la stratégie. Ces coûts doivent être pleinement pris en compte avant les transactions en direct et les conditions de coûts de transaction réelles doivent être simulées dans le rétro-analyse.
Le défi de la technologieLes stratégies à haute fréquence exigent des systèmes de négociation avec une latence extrêmement faible et une grande fiabilité. Tout retard de réseau, retard de données ou retard d’exécution peut entraîner l’échec de la stratégie. Assurez-vous d’utiliser une infrastructure de négociation de niveau professionnel et des sources de données à faible latence.
Risque de fluctuation du marché: Dans des conditions de marché extrêmes (comme des nouvelles soudaines ou une pénurie de liquidité), les modèles de réseaux neuronaux peuvent ne pas être en mesure de prédire avec précision les mouvements de prix, ce qui entraîne des pertes importantes. Il est recommandé de définir des mesures de stop-loss et des limites de perte maximale par jour, et de suspendre la stratégie pendant les fluctuations extrêmes.
Optimisation de l’architecture des réseaux neuronaux:
Mécanisme d’ajustement des paramètres dynamiques:
Cadre de prévision intégré:
Amélioration de la gestion des risques:
Apprentissage et adaptation en temps réel:
La stratégie de négociation quantifiée d’optimisation des fluctuations de prix des différences de réseaux neuronaux représente une pratique de pointe de la négociation quantifiée moderne, appliquant avec succès la technologie des réseaux neuronaux artificiels dans le domaine de la négociation à haute fréquence. Grâce à une structure de réseau neuronal multicouche soigneusement conçue, la stratégie est capable de capturer des modèles subtils dans les variations de prix à court terme et d’améliorer la qualité des transactions grâce à de multiples mécanismes de filtrage.
Le facteur de gain de 3.754 prouve que la stratégie a bien fonctionné dans l’environnement de test, mais la mise en œuvre pratique nécessite toujours de prendre en compte les risques liés aux surmesures, à la sensibilité des paramètres et aux transactions à haute fréquence. La stratégie a le potentiel de rester compétitive à long terme dans le domaine des transactions quantifiées hautement compétitives en optimisant continuellement l’architecture des réseaux neuronaux, en permettant un ajustement dynamique des paramètres et en renforçant la gestion des risques.
Le facteur clé de la réussite de la stratégie réside dans la combinaison de technologies de réseaux neuronaux complexes et de logiques de négociation pratiques, qui exploitent à la fois les capacités prédictives de l’apprentissage automatique et la faisabilité des transactions réelles. Pour les traders expérimentés en quantification, cela fournit un cadre extensible qui peut être davantage personnalisé et optimisé en fonction des différents marchés et des préférences de risque individuelles.
/*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)