Oscillateur à double piste RSI, stratégie de trading bidirectionnelle longue et courte
Date de création:
2023-10-25 11:57:46
Dernière modification:
2023-10-25 11:57:46
Copier:
1
Nombre de clics:
627
ChaoZhang
1
Suivre
1617
Abonnés
Aperçu
La stratégie de négociation bidirectionnelle est une stratégie de négociation bidirectionnelle utilisant l’indicateur RSI. La stratégie utilise le principe de sur-achat et de sur-vente de l’indicateur RSI, combinant la configuration des deux orbites et le signal de négociation uniforme, pour réaliser des positions d’ouverture et de clôture bidirectionnelles efficaces.
Principe de stratégie
La stratégie est principalement basée sur le principe de sur-achat et de sur-vente de l’indicateur RSI. La stratégie calcule d’abord la valeur vrsi de l’indicateur RSI, ainsi que la trajectoire supérieure sn et la trajectoire inférieure ln.
La stratégie détecte également les variations de K-ligne à la baisse et génère un signal de plus en plus long Locic. Plus précisément, la stratégie génère un signal de plus en plus long Locic lorsque la ligne K passe de bas en haut et un signal de plus en plus court Logic lorsque la ligne K passe de haut en bas. De plus, la stratégie fournit un commutateur de paramètres permettant de ne faire que plus, de ne faire que vide ou de renverser le signal.
Après avoir généré plusieurs signaux de prise de position, la stratégie calcule le nombre de signaux et contrôle le nombre d’ouvertures de position. Différentes règles de prise de position peuvent être configurées via des paramètres. Les conditions de placement peuvent inclure des arrêts, des arrêts de perte et des arrêts de perte mobiles.
En résumé, la stratégie utilise une combinaison de techniques telles que l’indicateur RSI, le croisement de la moyenne, la mise en bourse statistique et le stop-loss pour réaliser des transactions bidirectionnelles automatiques.
Avantages stratégiques
- Utilisez le principe de l’indicateur RSI de sur-achat et de sur-vente pour établir des positions de courtage supplémentaires dans des positions raisonnables.
- Les deux voies sont réglées pour éviter les signaux erronés. La voie supérieure empêche les positions multiples de se stabiliser trop tôt et la voie inférieure empêche les positions vides de se stabiliser trop tôt.
- Les signaux de négociation de la moyenne filtrent les fausses ruptures. Les signaux de rupture de la moyenne sont générés par les cours, afin d’éviter les fausses ruptures.
- Le nombre de signaux statistiques et le nombre de prises de position, le contrôle des risques.
- Le pourcentage de stop loss est personnalisable et le risque de gain est contrôlable.
- Les stop-loss mobiles suivent les stop-loss et permettent de verrouiller les profits.
- Il est possible de faire plus, de faire moins ou de faire des signaux de retournement pour s’adapter à différents environnements de marché.
- L’automatisation des systèmes de négociation réduit le coût de l’exploitation.
Risque stratégique
- Il existe un risque d’échec de l’indicateur RSI.
- Il existe un risque d’arrêt de la perte d’arrêt fixe. Une mauvaise configuration de la perte d’arrêt peut entraîner une perte ou une perte d’arrêt prématurée.
- Le risque d’optimisation des paramètres dépend de l’indicateur technique. Un paramètre d’indicateur mal défini peut affecter l’efficacité de la stratégie.
- Il y a un risque de déclenchement simultané de plusieurs conditions.
- Les systèmes de négociation automatique présentent un risque d’erreur inhabituelle.
Pour répondre à ces risques, il est possible d’optimiser les paramètres, d’ajuster la stratégie de stop loss, d’augmenter le filtrage de la liquidité, d’optimiser la logique de génération de signaux, d’ajouter la surveillance des erreurs d’exception, etc.
Orientation de l’optimisation de la stratégie
- Test des paramètres de l’indicateur RSI optimisé pour différentes périodes.
- Testez différents réglages pour le pourcentage de stop loss.
- Augmenter le volume de transactions ou le filtrage des taux de rendement pour éviter une mobilité insuffisante.
- Optimisation de la logique de génération de signaux et amélioration de l’intersection de la ligne moyenne.
- Augmentation de la période de répétition pour vérifier la stabilité.
- Envisagez d’ajouter d’autres indicateurs pour optimiser l’efficacité du signal.
- Adhérer à une stratégie de gestion de position.
- Il a ajouté que la surveillance des anomalies serait renforcée.
- Optimisation des algorithmes de suivi automatique des pertes.
- Envisagez d’inclure des stratégies d’amélioration de l’apprentissage automatique.
Résumer
La stratégie de trading bidirectionnel RSI est une stratégie de trading bidirectionnel basée sur l’utilisation d’indicateurs RSI, des principes d’ouverture et de fermeture statistiques et d’autres techniques. Elle est très personnalisable et permet aux utilisateurs d’ajuster les paramètres en fonction de leurs besoins et de s’adapter à différents environnements de marché.
Code source de la stratégie
/*backtest
start: 2023-09-24 00:00:00
end: 2023-10-24 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=3
// Learn more about Autoview and how you can automate strategies like this one here: https://autoview.with.pink/
// strategy("Autoview Build-a-bot - 5m chart", "Strategy", overlay=true, pyramiding=2000, default_qty_value=10000)
// study("Autoview Build-a-bot", "Alerts")
///////////////////////////////////////////////
//* Backtesting Period Selector | Component *//
///////////////////////////////////////////////
//* https://www.tradingview.com/script/eCC1cvxQ-Backtesting-Period-Selector-Component *//
//* https://www.tradingview.com/u/pbergden/ *//
//* Modifications made *//
testStartYear = input(1, "Backtest Start Year")
testStartMonth = input(11, "Backtest Start Month")
testStartDay = input(10, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay,0,0)
testStopYear = input(77777777, "Backtest Stop Year")
testStopMonth = input(11, "Backtest Stop Month")
testStopDay = input(15, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay,0,0)
testPeriod() => true
/////////////////////////////////////
//* Put your strategy logic below *//
/////////////////////////////////////
RSIlength = input(1,title="RSI Period Length")
price = close
vrsi = (rsi(price, RSIlength))
src = close
len = input(2, minval=1, title="Length")
up = rma(max(change(src), 0), len)
down = rma(-min(change(src), 0), len)
rsi = down == 0 ? 100 : up == 0 ? 0 : 100 - (100 / (1 + up / down))
rsin = input(12)
sn = 100 - rsin
ln = 0 + rsin
// Put your long and short rules here
longLocic = crossunder(rsi, ln)
shortLogic = crossover(rsi, sn)
//////////////////////////
//* Strategy Component *//
//////////////////////////
isLong = input(true, "Longs Only")
isShort = input(false, "Shorts Only")
isFlip = input(false, "Flip the Opens")
long = longLocic
short = shortLogic
if isFlip
long := shortLogic
short := longLocic
else
long := longLocic
short := shortLogic
if isLong
long := long
short := na
if isShort
long := na
short := short
////////////////////////////////
//======[ Signal Count ]======//
////////////////////////////////
sectionLongs = 0
sectionLongs := nz(sectionLongs[1])
sectionShorts = 0
sectionShorts := nz(sectionShorts[1])
if long
sectionLongs := sectionLongs + 1
sectionShorts := 0
if short
sectionLongs := 0
sectionShorts := sectionShorts + 1
//////////////////////////////
//======[ Pyramiding ]======//
//////////////////////////////
pyrl = input(2, "Pyramiding less than") // If your count is less than this number
pyre = input(1, "Pyramiding equal to") // If your count is equal to this number
pyrg = input(1000000, "Pyramiding greater than") // If your count is greater than this number
longCondition = long and sectionLongs <= pyrl or long and sectionLongs >= pyrg or long and sectionLongs == pyre ? 1 : 0 and vrsi < 20
shortCondition = short and sectionShorts <= pyrl or short and sectionShorts >= pyrg or short and sectionShorts == pyre ? 1 : 0
////////////////////////////////
//======[ Entry Prices ]======//
////////////////////////////////
last_open_longCondition = na
last_open_shortCondition = na
last_open_longCondition := longCondition ? close : nz(last_open_longCondition[1])
last_open_shortCondition := shortCondition ? close : nz(last_open_shortCondition[1])
////////////////////////////////////
//======[ Open Order Count ]======//
////////////////////////////////////
sectionLongConditions = 0
sectionLongConditions := nz(sectionLongConditions[1])
sectionShortConditions = 0
sectionShortConditions := nz(sectionShortConditions[1])
if longCondition
sectionLongConditions := sectionLongConditions + 1
sectionShortConditions := 0
if shortCondition
sectionLongConditions := 0
sectionShortConditions := sectionShortConditions + 1
///////////////////////////////////////////////
//======[ Position Check (long/short) ]======//
///////////////////////////////////////////////
last_longCondition = na
last_shortCondition = na
last_longCondition := longCondition ? time : nz(last_longCondition[1])
last_shortCondition := shortCondition ? time : nz(last_shortCondition[1])
in_longCondition = last_longCondition > last_shortCondition
in_shortCondition = last_shortCondition > last_longCondition
/////////////////////////////////////
//======[ Position Averages ]======//
/////////////////////////////////////
totalLongs = 0.0
totalLongs := nz(totalLongs[1])
totalShorts = 0.0
totalShorts := nz(totalShorts[1])
averageLongs = 0.0
averageLongs := nz(averageLongs[1])
averageShorts = 0.0
averageShorts := nz(averageShorts[1])
if longCondition
totalLongs := totalLongs + last_open_longCondition
totalShorts := 0.0
if shortCondition
totalLongs := 0.0
totalShorts := totalShorts + last_open_shortCondition
averageLongs := totalLongs / sectionLongConditions
averageShorts := totalShorts / sectionShortConditions
/////////////////////////////////
//======[ Trailing Stop ]======//
/////////////////////////////////
isTS = input(false, "Trailing Stop")
tsi = input(100, "Activate Trailing Stop Price (%). Divided by 100 (1 = 0.01%)") / 100
ts = input(100, "Trailing Stop (%). Divided by 100 (1 = 0.01%)") / 100
last_high = na
last_low = na
last_high_short = na
last_low_short = na
last_high := not in_longCondition ? na : in_longCondition and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_high_short := not in_shortCondition ? na : in_shortCondition and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_shortCondition ? na : in_shortCondition and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])
last_low_short := not in_longCondition ? na : in_longCondition and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])
long_ts = isTS and not na(last_high) and low <= last_high - last_high / 100 * ts and longCondition == 0 and last_high >= averageLongs + averageLongs / 100 * tsi
short_ts = isTS and not na(last_low) and high >= last_low + last_low / 100 * ts and shortCondition == 0 and last_low <= averageShorts - averageShorts/ 100 * tsi
///////////////////////////////
//======[ Take Profit ]======//
///////////////////////////////
isTP = input(true, "Take Profit")
tp = input(125, "Take Profit (%). Divided by 100 (1 = 0.01%)") / 100
long_tp = isTP and close > averageLongs + averageLongs / 100 * tp and not longCondition
short_tp = isTP and close < averageShorts - averageShorts / 100 * tp and not shortCondition
/////////////////////////////
//======[ Stop Loss ]======//
/////////////////////////////
isSL = input(true, "Stop Loss")
sl = input(140, "Stop Loss (%). Divided by 100 (1 = 0.01%)") / 100
long_sl = isSL and close < averageLongs - averageLongs / 100 * sl and longCondition == 0
short_sl = isSL and close > averageShorts + averageShorts / 100 * sl and shortCondition == 0
/////////////////////////////////
//======[ Close Signals ]======//
/////////////////////////////////
longClose = long_tp or long_sl or long_ts ? 1 : 0
shortClose = short_tp or short_sl or short_ts ? 1: 0
///////////////////////////////
//======[ Plot Colors ]======//
///////////////////////////////
longCloseCol = na
shortCloseCol = na
longCloseCol := long_tp ? purple : long_sl ? maroon : long_ts ? blue : longCloseCol[1]
shortCloseCol := short_tp ? purple : short_sl ? maroon : short_ts ? blue : shortCloseCol[1]
tpColor = isTP and in_longCondition ? purple : isTP and in_shortCondition ? purple : white
slColor = isSL and in_longCondition ? red : isSL and in_shortCondition ? red : white
//////////////////////////////////
//======[ Strategy Plots ]======//
//////////////////////////////////
plot(isTS and in_longCondition ? averageLongs + averageLongs / 100 * tsi : na, "Long Trailing Activate", blue, style=3, linewidth=2)
plot(isTS and in_longCondition and last_high >= averageLongs + averageLongs / 100 * tsi ? last_high - last_high / 100 * ts : na, "Long Trailing", fuchsia, style=2, linewidth=3)
plot(isTS and in_shortCondition ? averageShorts - averageShorts/ 100 * tsi : na, "Short Trailing Activate", blue, style=3, linewidth=2)
plot(isTS and in_shortCondition and last_low <= averageShorts - averageShorts/ 100 * tsi ? last_low + last_low / 100 * ts : na, "Short Trailing", fuchsia, style=2, linewidth=3)
plot(isTP and in_longCondition and last_high < averageLongs + averageLongs / 100 * tp ? averageLongs + averageLongs / 100 * tp : na, "Long TP", tpColor, style=3, linewidth=2)
plot(isTP and in_shortCondition and last_low > averageShorts - averageShorts / 100 * tp ? averageShorts - averageShorts / 100 * tp : na, "Short TP", tpColor, style=3, linewidth=2)
plot(isSL and in_longCondition and last_low_short > averageLongs - averageLongs / 100 * sl ? averageLongs - averageLongs / 100 * sl : na, "Long SL", slColor, style=3, linewidth=2)
plot(isSL and in_shortCondition and last_high_short < averageShorts + averageShorts / 100 * sl ? averageShorts + averageShorts / 100 * sl : na, "Short SL", slColor, style=3, linewidth=2)
///////////////////////////////
//======[ Alert Plots ]======//
///////////////////////////////
// plot(longCondition, "Long", green)
// plot(shortCondition, "Short", red)
// plot(longClose, "Long Close", longCloseCol)
// plot(shortClose, "Short Close", shortCloseCol)
///////////////////////////////////
//======[ Reset Variables ]======//
///////////////////////////////////
if longClose or not in_longCondition
averageLongs := 0
totalLongs := 0.0
sectionLongs := 0
sectionLongConditions := 0
if shortClose or not in_shortCondition
averageShorts := 0
totalShorts := 0.0
sectionShorts := 0
sectionShortConditions := 0
////////////////////////////////////////////
//======[ Strategy Entry and Exits ]======//
////////////////////////////////////////////
if testPeriod()
strategy.entry("Long", 1, when=longCondition)
strategy.entry("Short", 0, when=shortCondition)
strategy.close("Long", when=longClose)
strategy.close("Short", when=shortClose)