Système de décision de négociation de tortues

Auteur:ChaoZhang est là., Date: le 29 février 2024 à 14:28:25
Les étiquettes:

Résumé

Le Turtle Trading Decision System est une stratégie de trading basée sur la théorie du breakout. Il génère des signaux de trading en déplaçant les moyennes des prix les plus élevés et les plus bas au cours de périodes spécifiques pour identifier les tendances potentielles. Les signaux de trading sont générés lorsque les prix dépassent ou sont inférieurs aux prix les plus élevés ou les plus bas au cours des périodes spécifiées.

Principe de stratégie

Les signaux de stratégie de base du système de décision de négociation de la tortue sont générés en comparant le prix avec les prix les plus élevés sur les périodes N1 et les prix les plus bas sur les périodes N2. Un signal long est généré lorsque le prix dépasse le prix le plus élevé sur les périodes N1. Un signal court est généré lorsque le prix dépasse le prix le plus bas sur les périodes N2. Le mode d'arrêt est utilisé pour contrôler la génération de nouveaux signaux.

Après avoir ouvert une position, le prix sera comparé au prix de stop loss en temps réel pour générer des signaux de stop trailing.

Lors de l'ouverture d'une position à chaque fois, l'unité de position est calculée en prenant un certain pourcentage du capital initial afin d'éviter l'impact d'une perte unique sur le capital total.

Analyse des avantages

Le système de décision sur le commerce des tortues présente les avantages suivants:

Capture des tendances potentielles: en comparant les prix avec les prix les plus élevés et les plus bas au cours des périodes pour déterminer les tendances potentielles, les tendances potentielles des prix peuvent être capturées plus tôt.
Gestion des risques: utiliser la gestion de l'argent et le stop loss pour contrôler les risques de perte individuels et globaux.
Gestion de la pyramide: une pyramide appropriée peut générer des bénéfices supplémentaires des tendances.
Intégrité: la combinaison de la gestion de l'argent, de la gestion des pertes et de la gestion des pyramides rend le système de décision plus complet.
Simple et clair: les règles de génération du signal sont simples et directes, faciles à comprendre et à vérifier.

Analyse des risques

Le système de décision de négociation des tortues comporte également certains risques:

Risque de fausse rupture: les prix peuvent avoir de fausses ruptures au-dessus ou en dessous des prix les plus élevés ou les plus bas, ce qui provoque des signaux erronés.
Risque d'inversion de tendance: il existe un risque que la perte augmente après la pyramide lorsque les prix s'inversent. Le nombre de pyramides doit être limité de manière appropriée et arrêter les pertes à temps.
Optimisation des paramètres de risque: les paramètres peuvent varier considérablement selon les marchés, les paramètres doivent être optimisés séparément pour chaque marché afin de réduire les risques.

Directions d'optimisation

Le système de décision de négociation des tortues peut également être optimisé dans les aspects suivants:

Ajouter des filtres: détecter l'élan des écarts de prix pour filtrer certaines fausses écarts.
Optimiser les stratégies de stop loss: comment suivre raisonnablement les stop loss et trouver un équilibre entre la protection des bénéfices et la réduction des stop loss inutiles.
Optimisation des paramètres par marché: optimiser les combinaisons de paramètres pour les caractéristiques des différentes variétés.
Ajoutez l'apprentissage automatique: Utilisez des algorithmes d'apprentissage automatique pour aider à juger des tendances.

Résumé

Le Turtle Trading Decision System juge la direction de la tendance potentielle en comparant les prix avec les prix les plus élevés et les plus bas au cours de périodes spécifiées, et construit l'ensemble du système de décision avec des modules de gestion des risques. Il a une forte capacité de suivi des tendances, et présente également certains risques de fausses ruptures et d'optimisation des paramètres. Cette stratégie peut servir de modèle de base pour le trading quantitatif, et être étendue et optimisée sur cette base pour développer des systèmes de décision appropriés pour vous-même.

/*backtest
start: 2024-01-29 00:00:00
end: 2024-02-28 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © 李和邪 
// 本脚本所有内容只适用于交流学习，不构成投资建议，所有后果自行承担。
//@version=5
strategy(title='Turtle Trading Strategy@lihexie',
   shorttitle='OKX-海龟交易系统@李和邪',
   overlay=true,
   pyramiding=4,
   initial_capital = 1000,
   default_qty_type = strategy.percent_of_equity,
   default_qty_value=100,
   slippage = 0,
   commission_type = strategy.commission.percent,
   commission_value = 0.05)

// 输入参数
from_date = input(timestamp("2013-01-01T00:00:00+08:00"), "From Date/开始日期")
end_date = input(timestamp("2024-08-01T00:00:00+08:00"), "To Date/结束日期")
valid_date() => true
current_mode = input.string("Mode 1", "Enter Mode/进场系统",['Mode 1','Mode 2'])
// mode 1
entry_length = input.int(20, 'Entry Length/系统1进场长度', minval=1)  // 进场长度
exit_length = input.int(10, 'Exit Length/系统2出场长度', minval=1)  // 出场长度
// mode 2
entry_length_mode2 = input.int(55, 'Mode2 Entry Length/系统2进场长度', minval=1)  // 进场长度
exit_length_mode2 = input.int(20, 'Mode2 Exit Length/系统2出场长度', minval=1) 
atr_period = input.int(14, "ATR Period/计算ATR的周期", minval=1)  // ATR周期
risk_per_trade = input.float(0.02, "Risk Per Trade/每笔交易的风险，0.02就是2%", minval=0.001, maxval=1)  // 每笔交易的风险
initial_stop_atr_multiple = input.float(2, "Initial Stop ATR Multiple/止损使用的ATR倍数", minval=0.1, maxval=10)  // 初始止损ATR倍数
pyramid_atr_multiple = input.float(0.5, "Pyramid ATR Multiple/加仓使用的ATR倍数", minval=0.1, maxval=10)  // 加仓ATR倍数
max_units = input.int(4, "Max Units/最大头寸单位数", minval=1, maxval=10)  // 最大头寸单位数

highlighting = input(title='Highlighter On/Off ?/是否高亮显示', defval=true)  // 是否高亮显示


// 初始化变量
var int units = 0
var float trailing_stop_long = na
var float trailing_stop_short = na
var float real_entry_price_long = na
var float real_entry_price_short = na
var float add_unit_price_long = na
var float add_unit_price_short = na
var bool last_trade_win = false
// 计算ATR
atr = ta.atr(atr_period)

// 计算单位大小
unit_size = (strategy.equity * risk_per_trade) / (initial_stop_atr_multiple * atr)

// 切换模式
mode_signal = current_mode == "Mode 1" ? (last_trade_win==false?true:false) : true

float entry_price_long = na
float entry_price_short = na
float exit_price_long = na
float exit_price_short = na
// 计算进场和出场价格
if current_mode == "Mode 1"
    entry_price_long := ta.highest(entry_length)
    entry_price_short := ta.lowest(entry_length)
    exit_price_long := ta.lowest(exit_length)
    exit_price_short := ta.highest(exit_length)
else
    entry_price_long := ta.highest(entry_length_mode2)
    entry_price_short := ta.lowest(entry_length_mode2)
    exit_price_long := ta.lowest(exit_length_mode2)
    exit_price_short := ta.highest(exit_length_mode2)

// 计算止损价格
stop_price_long = entry_price_long - (initial_stop_atr_multiple * atr)
stop_price_short = entry_price_short + (initial_stop_atr_multiple * atr)

// 交易逻辑
// 生成买入和卖出信号
long_signal = ta.crossover(close, entry_price_long[1]) and strategy.position_size==0 and valid_date()
short_signal = ta.crossunder(close, entry_price_short[1]) and strategy.position_size==0 and valid_date()
// 生成出场信号
exit_long_signal = ta.crossunder(close, exit_price_long[1]) and strategy.position_size > 0 and valid_date()
exit_short_signal = ta.crossover(close, exit_price_short[1]) and strategy.position_size < 0 and valid_date()

if long_signal 
    if mode_signal
        strategy.entry("Long", strategy.long, qty=unit_size, stop=stop_price_long)
        units := 1
        trailing_stop_long := stop_price_long
        real_entry_price_long := close
        add_unit_price_long := real_entry_price_long+pyramid_atr_multiple*atr
    else
        last_trade_win:=false
if short_signal 
    if mode_signal
        strategy.entry("Short", strategy.short, qty=unit_size, stop=stop_price_short)
        units := 1
        trailing_stop_short := stop_price_short
        real_entry_price_short := close
        add_unit_price_short := real_entry_price_short-pyramid_atr_multiple*atr
    else
        last_trade_win:=false
// 出场逻辑
if exit_long_signal
    last_trade_win := strategy.position_avg_price<close?true:false
    strategy.close_all("SL")
    units := 0
    real_entry_price_long := na
    add_unit_price_long := na
    trailing_stop_long := na
if exit_short_signal
    last_trade_win := strategy.position_avg_price>close?true:false
    strategy.close_all("SS")
    units := 0
    real_entry_price_short := na
    add_unit_price_short := na
    trailing_stop_short := na

// 生成加仓信号
add_unit_signal = (close > add_unit_price_long or close < add_unit_price_short) and units[1] < max_units and valid_date()
// 加仓逻辑
if add_unit_signal
    if strategy.position_size > 0
        strategy.entry("AL", strategy.long, qty=unit_size)
        real_entry_price_long := close
        add_unit_price_long := real_entry_price_long+pyramid_atr_multiple*atr
        trailing_stop_long := real_entry_price_long - (initial_stop_atr_multiple * atr)
    if strategy.position_size < 0
        strategy.entry("AS", strategy.short, qty=unit_size)
        real_entry_price_short := close
        add_unit_price_short := real_entry_price_short-pyramid_atr_multiple*atr
        trailing_stop_short := real_entry_price_short + (initial_stop_atr_multiple * atr)
    units := units + 1

// 移动止损逻辑
trailing_stop_long_signal = ta.crossunder(close, trailing_stop_long) and strategy.position_size > 0 and valid_date()
trailing_stop_short_signal = ta.crossover(close, trailing_stop_short) and strategy.position_size < 0 and valid_date()

if trailing_stop_long_signal
    last_trade_win := strategy.position_avg_price<close?true:false
    strategy.close_all("TSL")
    units := 0
    real_entry_price_long := na
    add_unit_price_long := na
    trailing_stop_long := na
if trailing_stop_short_signal
    last_trade_win := strategy.position_avg_price>close?true:false
    strategy.close_all("TSS")
    units := 0
    real_entry_price_short := na
    add_unit_price_short := na
    trailing_stop_short := na

// 美化图表
plot_entry_lowest = plot(entry_price_short, 'Lower', color=color.new(#0094FF, 0))  // 绘制进场最低线
plot_entry_highest = plot(entry_price_long, 'Upper', color=color.new(#0094FF, 0))  // 绘制进场最高线
entry_line = ta.barssince(short_signal) <= ta.barssince(long_signal) ? entry_price_short : entry_price_long  // 进场线
exit_line = ta.barssince(short_signal) <= ta.barssince(long_signal) ? exit_price_short : exit_price_long  // 出场线
plot(entry_line, title='Trend Line', color=color.new(#ff52f1, 0), linewidth=2)  // 绘制趋势线
plot_exit = plot(exit_line, title='Exit Line', color=color.new(color.blue, 0), linewidth=1, style=plot.style_circles)  // 绘制出场线

entry_long_color = highlighting and strategy.position_size>0 ? color.new(color.green, transp = 88) : na
entry_short_color = highlighting and strategy.position_size<0 ? color.new(color.red, transp = 88) : na
fill(plot_entry_highest, plot_exit, color=entry_long_color, title='Background') // 高亮多头趋势
fill(plot_entry_lowest, plot_exit, color=entry_short_color, title='Background') // 高亮空头趋势

Plus de

2019 FMZ - Tous les droits réservés