Sumber daya yang dimuat... Pemuatan...

Strategi Perdagangan Crossover QQE Cepat Berdasarkan Filter Tren

Penulis:ChaoZhang, Tanggal: 2024-01-25 11:34:58
Tag:

Gambaran umum

Strategi perdagangan crossover QQE cepat berdasarkan filter tren adalah strategi perdagangan mengikuti tren yang menggunakan persilangan QQE cepat dengan Moving Averages untuk penyaringan arah tren. QQE atau Estimasi Kuantitatif Kualitatif didasarkan pada indeks kekuatan relatif, tetapi menggunakan teknik pelunturan sebagai transformasi tambahan. Tiga persilangan dapat dipilih (semua dipilih secara default):

RSI sinyal melintasi ZERO (XZERO)
Sinyal RSI melintasi garis RSIat cepat (XQQE)
Sinyal RSI keluar dari RSI Threshold Channel (BUY/SELL)

Pemberitahuan (BUY/SELL) dapat disaring secara opsional dengan moving averages:

Untuk peringatan BUY, Close harus berada di atas MA cepat dan MA cepat (EMA8) > MA menengah (EMA20) > MA lambat (SMA50).
Untuk peringatan SELL, Close harus berada di bawah MA cepat dan MA cepat (EMA8) < MA menengah (EMA20) < MA lambat (SMA50).

dan/atau filter arah:

Untuk peringatan BUY, Close harus berada di atas slow MA (SMA50) dan directional MA (EMA20) harus berwarna hijau.
Untuk peringatan SELL, Close harus berada di bawah slow MA (SMA50) dan directional MA (EMA20) harus merah.

XZERO dan XQQE tidak termasuk dalam penyaringan, mereka digunakan untuk menunjukkan peringatan BUY / SELL yang sedang menunggu, terutama XZERO.

Strategi ini harus bekerja pada setiap pasangan mata uang dan sebagian besar kerangka waktu grafik.

Prinsip Strategi

Ide inti dari strategi ini adalah menggunakan lintas arah indikator QQE cepat sebagai sinyal perdagangan dan menyaring sinyal perdagangan yang bising melalui kombinasi rata-rata bergerak untuk menangkap arah tren.

Secara khusus, strategi ini menggunakan indikator dan sinyal berikut:

Indikator QQE CepatIni adalah indikator berbasis RSI dengan perataan tambahan untuk membuatnya lebih sensitif dan cepat. Indikator ini terdiri dari tiga garis: garis tengah adalah rata-rata bergerak eksponensial RSI, garis atas adalah garis tengah + cepat ATR * faktor, dan garis bawah adalah garis tengah - cepat ATR * faktor. Ketika RSI naik di atas garis atas, itu adalah sinyal jual. Ketika RSI turun di bawah garis bawah, itu adalah sinyal beli.

Zero Line Crossover: Ini menghasilkan sinyal ketika garis tengah RSI melintasi garis nol. Crossover ke atas adalah sinyal beli dan crossover ke bawah adalah sinyal jual. Sinyal ini menunjukkan awal perubahan tren.

Penembusan saluran: Ini menghasilkan sinyal ketika garis tengah RSI memasuki saluran ambang yang ditetapkan. Melanggar saluran atas adalah sinyal jual dan melanggar saluran bawah adalah sinyal beli. Ini adalah sinyal tren yang lebih kuat.

Kombo Rata-rata Bergerak: Gunakan kombinasi rata-rata bergerak cepat (8 periode), medium (20 periode) dan lambat (50 periode). Ketika tiga garis diatur sebagai: cepat > medium > lambat, itu adalah tren naik. Ketika diatur sebagai cepat < medium < lambat, itu adalah tren menurun.

Filter Arah Tren: Sinyal beli hanya dihasilkan ketika harga penutupan berada di atas rata-rata bergerak lambat dan rata-rata bergerak menengah (20 periode) naik (harga tertinggi periode > harga terendah). Sinyal jual hanya dihasilkan ketika harga penutupan berada di bawah rata-rata bergerak lambat dan rata-rata bergerak menengah (20 periode) menurun. Ini dapat menyaring beberapa sinyal palsu terbalik.

Dengan menggabungkan penggunaan sinyal silang dari indikator QQE cepat dan penyaringan tren dari rata-rata bergerak, ia menangkap titik pembalikan jangka pendek pada tren kerangka waktu utama untuk membentuk sistem perdagangan yang relatif lengkap.

Singkatnya, ini adalah strategi yang melacak tren jangka menengah dan panjang, menggunakan indikator cepat untuk menangkap waktu pembalikan jangka pendek untuk masuk / keluar, dan memanfaatkan penyaringan rata-rata bergerak untuk mengurangi risiko perdagangan melawan arah dan dengan demikian memaksimalkan pengembalian.

Keuntungan dari Strategi

Menggunakan indikator QQE cepat dan sensitif untuk cepat menangkap sinyal pembalikan
Menggunakan beberapa rata-rata bergerak untuk menentukan arah siklus besar dan menghindari perdagangan melawan tren
Termasuk beberapa sinyal silang yang dapat digunakan dalam kombinasi untuk meningkatkan peluang keuntungan
Parameter yang dapat disesuaikan yang dapat dioptimalkan untuk produk dan kerangka waktu yang berbeda
Menggunakan indikators sendiri sinyal saluran pecah alih-alih menggambar saluran terpisah, menghindari ketergantungan parameter
Dapat menangkap gerakan pembalikan jangka pendek dengan sangat baik di bawah siklus tren besar
Konsep sederhana dan jelas, mudah dipahami dan diterapkan

Risiko dari Strategi

Ada juga beberapa risiko potensial dengan strategi ini:

Indikator cepat cenderung menghasilkan sinyal palsu yang tidak dapat sepenuhnya disaring oleh rata-rata bergerak, risiko melacak arah yang salah ada
Ketika pembalikan tren siklus besar terjadi, sinyal perdagangan terbalik cenderung terbentuk yang menimbulkan risiko
Tidak ada pertimbangan faktor pengelolaan uang, risiko perdagangan berlebihan dan kerugian ada
Tidak ada stop loss di tempat, risiko perluasan kerugian besar
Risiko penyesuaian data backtest, kinerja aktual masih harus diverifikasi

Pengendalian dan solusi meliputi:

Sesuaikan parameter rata-rata bergerak, gunakan lebih banyak panjang siklus untuk menentukan tren
Tambahkan indikator lain seperti MACD, bias dll untuk penyaringan combo
Tambahkan strategi stop loss untuk mengontrol ukuran kerugian perdagangan tunggal
Pengujian uang riil, mengoptimalkan parameter

Arahan Optimasi

Ada ruang untuk optimalisasi lebih lanjut dari strategi ini:

Mengoptimalkan parameter garis cepat dan lambat dari indikator QQE untuk menemukan kombinasi parameter yang optimal
Uji lebih banyak kombinasi rata-rata bergerak untuk menemukan kinerja penyaringan yang optimal
Tambahkan indikator lain seperti MACD untuk penyaringan sinyal tambahan
Menerapkan strategi manajemen uang untuk mengoptimalkan ukuran posisi
Tetapkan strategi stop loss untuk mengendalikan risiko penurunan per perdagangan
Mengoptimalkan parameter berdasarkan produk yang berbeda
Tentukan tren pada jangka waktu yang lebih panjang untuk menghindari tertipu oleh pembalikan jangka pendek

Dengan pengoptimalan parameter, menggabungkan lebih banyak indikator, dan dibantu oleh praktik pengelolaan uang dan risiko yang layak, kinerja strategi ini dapat ditingkatkan untuk perdagangan nyata.

Kesimpulan

Secara keseluruhan, strategi perdagangan crossover QQE yang cepat berdasarkan filter tren adalah pilihan yang sangat besar. Kekuatannya terletak pada cepat menangkap peluang perdagangan pembalikan sambil menggunakan beberapa rata-rata bergerak untuk menentukan tren utama dan menghindari perdagangan melawan mereka sebanyak mungkin. Dengan pengoptimalan parameter indikator dan kriteria penyaringan, ditambah dengan manajemen uang yang ketat, strategi ini dapat menghasilkan laba investasi yang relatif stabil.

Tentu saja risiko tidak dapat diabaikan. pengujian uang riil dan penyesuaian optimasi terus-menerus diperlukan untuk memastikan kepraktisan dan keandalan strategi. Kesimpulannya, bermanfaat bagi investor untuk mempelajari dan melacak praktik jangka panjang. Diyakini bahwa dengan kemajuan teknologi perdagangan algoritmik, jenis strategi yang didasarkan pada indikator cepat dan penyaringan tren akan melihat peningkatan dan proliferasi lebih lanjut.

/*backtest
start: 2024-01-17 00:00:00
end: 2024-01-24 00:00:00
period: 5m
basePeriod: 1m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=2
//
// Title:   [STRATEGY][UL]QQE Cross v1.1
// Author:  JustUncleL
// Date:    22-Oct-2016
// Version: v1.1
//
// Description:
//  A trend following trading Strategy that uses fast QQE crosses with Moving Averages
//  for trend direction filtering. QQE or Qualitative Quantitative Estimation is based 
//  on the relative strength index, but uses a smoothing technique as an additional 
//  transformation. Three crosses can be selected (all selected by default): 
//    - RSI signal crossing ZERO (XZERO)
//    - RSI signal crossing Fast RSIatr line (XQQE)
//    - RSI signal exiting the RSI Threshhold Channel (BUY/SELL)
//  The (BUY/SELL) alerts can be optionally filtered by the Moving averages:
//    - For BUY alert the Close must be above the fast MA and 
//        fast MA (EMA8) > medium MA (EMA20) > slow MA (SMA50).
//    - For SELL alert the Close must be below the fast MA and
//        fast MA (EMA8) < medium MA (EMA20) < slow MA (SMA50).
//  and/or directional filter:
//    - For BUY alert the Close must be above the slow MA (SMA50) and the
//      directional MA (EMA20) must be green.
//    - For SELL alert the Close must be below the slow MA (SMA50) and the
//      directional MA (EMA20) must be red.
//. The XZERO and XQQE are not included in the filtering, they are used to indicate
//  pending BUY/SELL alerts, particularly the XZERO. 
//
//  This Strategy should work on any currency pair and most chart timeframes.
//  *** USE AT YOUR OWN RISK ***
//  
// 
//
// Mofidifications:
//  1.1 - Added Target Profit option, cleaned up the risk management code.
//        Changed Trade Close to EMA20 direction change instead of opposite BUY/SELL
//        signal, which will be earlier, this means stop loss setting should not be
//        required when an AutoTrader is available.
//        Modified code to prevent potential repaint issues.
//  1.0 - original
//
// References:
//  Some Code borrowed from:
//  - "Scalp Jockey - MTF MA Cross Visual Strategizer by JayRogers"
//  - "QQE MT4 by glaz"
//  - "Strategy Code Example by JayRogers"  
//  Inspiration from:
//  - http://www.forexstrategiesresources.com/binary-options-strategies-ii/189-aurora-binary-trading/
//  - http://www.forexstrategiesresources.com/metatrader-4-trading-systems-v/652-qqe-smoothed-trading/
//  - http://dewinforex.com/forex-indicators/qqe-indicator-not-quite-grail-but-accurately-defines-trend-and-flat.html
//

strategy(title='[STRATEGY][UL]QQE Cross v1.1', pyramiding=0, overlay=true )


// - INPUTS START
// Fast MA - type, source, length
type1   = input(defval="EMA", title="Fast MA Type: SMA, EMA, WMA, VWMA, SMMA, DEMA, TEMA, HullMA, ZEMA ( case sensitive )")
len1    = input(defval=8, title="Fast - Length", minval=1)
// Medium Fast MA - type, source, length
type2   = input(defval="EMA", title="Medium Fast MA Type: SMA, EMA, WMA, VWMA, SMMA, DEMA, TEMA, HullMA, ZEMA ( case sensitive )")
len2    = input(defval=20, title="Medium Fast - Length", minval=1)
// Slow MA - type, source, length
type3   = input(defval="SMA", title="Slow MA Type: SMA, EMA, WMA, VWMA, SMMA, DEMA, TEMA, HullMA, LSMA, ZEMA ( case sensitive )")
len3    = input(defval=50, title="Slow Length", minval=1)
//
// QQE rsi Length, Smoothing, fast ATR factor, source
RSILen  = input(6,title='RSI Length')
SF      = input(3,title='RSI Smoothing Factor')
QQE     = input(2.618,title='Fast QQE Factor')
threshhold = input(10, title="RSI Threshhold")
//
sQQEx   = input(false,title="Show QQE Signal crosses")
sQQEz   = input(false,title="Show QQE Zero crosses")
//
filter  = input(false,title="Use Moving Average Filter")
dfilter = input(true, title="Use Trend Directional Filter" )
RSIsrc  = input(close,title="Source")
srcclose= RSIsrc

// - INPUTS END

// - FUNCTIONS

// Returns MA input selection variant, default to SMA if blank or typo.
variant(type, src, len) =>
    v1 = sma(src, len)                                                  // Simple
    v2 = ema(src, len)                                                  // Exponential
    v3 = wma(src, len)                                                  // Weighted
    v4 = vwma(src, len)                                                 // Volume Weighted
    v5 = na(v5[1]) ? sma(src, len) : (v5[1] * (len - 1) + src) / len    // Smoothed
    v6 = 2 * v2 - ema(v2, len)                                          // Double Exponential
    v7 = 3 * (v2 - ema(v2, len)) + ema(ema(v2, len), len)               // Triple Exponential
    v8 = wma(2 * wma(src, len / 2) - wma(src, len), round(sqrt(len)))   // Hull
    ema1 = ema(src, len)
    ema2 = ema(ema1, len)
    v10 = ema1+(ema1-ema2)                                              // Zero Lag Exponential
    // return variant, defaults to SMA if input invalid.
    type=="EMA"?v2 : type=="WMA"?v3 : type=="VWMA"?v4 : type=="SMMA"?v5 : type=="DEMA"?v6 : type=="TEMA"?v7 : type=="HullMA"?v8 : type=="ZEMA"?v10 : v1

// - FUNCTIONS END

// - Fast ATR QQE
//
Wilders_Period = RSILen * 2 - 1
//
Rsi = rsi(RSIsrc,RSILen)
RSIndex = ema(Rsi, SF)
AtrRsi = abs(RSIndex[1] - RSIndex)
MaAtrRsi = ema(AtrRsi, Wilders_Period)
DeltaFastAtrRsi = ema(MaAtrRsi,Wilders_Period) * QQE
//
newshortband=  RSIndex + DeltaFastAtrRsi
newlongband= RSIndex - DeltaFastAtrRsi
longband=RSIndex[1] > longband[1] and RSIndex > longband[1] ? max(longband[1],newlongband) : newlongband
shortband=RSIndex[1] < shortband[1] and  RSIndex < shortband[1] ? min(shortband[1],newshortband) : newshortband
trend=cross(RSIndex, shortband[1])? 1 : cross(longband[1], RSIndex) ? -1 : nz(trend[1],1)
FastAtrRsiTL = trend==1 ? longband : shortband


// - SERIES VARIABLES
// MA's
ma_fast    = variant(type1, srcclose, len1)
ma_medium  = variant(type2, srcclose, len2)
ma_slow    = variant(type3, srcclose, len3)
// Get Direction From Medium Moving Average
direction = rising(ma_medium,3) ? 1 : falling(ma_medium,3) ? -1 : 0
//
// Find all the QQE Crosses
QQExshort = sQQEx and crossover(FastAtrRsiTL, RSIndex)
QQExlong  = sQQEx and crossunder(FastAtrRsiTL, RSIndex)
// Zero cross
QQEzlong = sQQEz and crossover(RSIndex,50)
QQEzshort  = sQQEz and crossunder(RSIndex,50)
//  
// Thresh Hold channel Crosses give the BUY/SELL alerts.
QQEclong = RSIndex>(50+threshhold) ? na(QQEclong[1]) ? 1 : QQEclong[1]+1 : 0
QQEcshort = RSIndex<(50-threshhold) ? na(QQEcshort[1]) ? 1 : QQEcshort[1]+1 : 0

//
// Check Filtering.
QQEflong = (not filter or (srcclose>ma_fast and ma_medium>ma_slow and ma_fast>ma_medium)) and 
  (not dfilter or (direction>0 and srcclose>ma_slow))
QQEfshort = (not filter or (srcclose<ma_fast and ma_medium<ma_slow and ma_fast<ma_medium)) and
  (not dfilter or (direction<0 and srcclose<ma_slow))
//
// Get final BUY / SELL alert determination
buy = QQEclong>0 and QQEflong ? na(buy[1]) ? 1 : buy[1]+1 : 0
sell= QQEcshort>0 and QQEfshort ? na(sell[1]) ? 1 : sell[1]+1 : 0

// - SERIES VARIABLES END

// - PLOTTING
// Ma's
plot(ma_fast, title="MA Fast", color=olive, linewidth=2, transp=20)
plot(ma_medium, title="MA Medium Fast", color=direction<0?red:green, linewidth=3, transp=0)
plot(ma_slow, title="MA Slow", color=blue, linewidth=2, transp=20)
// QQE crosses
plotshape(QQExlong and buy!=1, title="QQE Cross Over", style=shape.triangleup, location=location.belowbar, text="XQQE", color=blue, transp=20, size=size.tiny)
plotshape(QQExshort and sell!=1, title="QQE Cross Under", style=shape.triangledown, location=location.abovebar, text="XQQE", color=black, transp=20, size=size.tiny)
// Signal crosses zero line
plotshape(QQEzlong and buy!=1 and not QQExlong, title="QQE Zero Cross Over", style=shape.triangleup, location=location.belowbar, text="XZERO", color=aqua, transp=20, size=size.tiny)
plotshape(QQEzshort and sell!=1 and not QQExshort, title="QQE Zero Cross Under", style=shape.triangledown, location=location.abovebar, text="XZERO", color=fuchsia, transp=20, size=size.tiny)

// - PLOTTING END

// Create alert for cross, shunt back 1 if source is not 'open', this should prevent repaint issue.
//shunt = RSIsrc == open ? 0 : 1
shunt = 0
c_alert = (buy[shunt]==1 or sell[shunt]==1)
//alertcondition(c_alert, title="QQECROSS Alert", message="QQECROSS Alert")
// show only when alert condition is met and bar closed.
plotshape(c_alert,title= "Alert Indicator Closed", location=location.bottom, color=sell[shunt]==1?red:green, transp=0, style=shape.circle)


//  Strategy: (Thanks to JayRogers)
// === STRATEGY RELATED INPUTS ===
//tradeInvert     = input(defval = false, title = "Invert Trade Direction?")
// the risk management inputs
inpTakeProfit   = input(defval = 0, title = "Take Profit Points", minval = 0)
inpStopLoss     = input(defval = 0, title = "Stop Loss Points", minval = 0)
inpTrailStop    = input(defval = 100, title = "Trailing Stop Loss Points", minval = 0)
inpTrailOffset  = input(defval = 0, title = "Trailing Stop Loss Offset Points", minval = 0)

// === RISK MANAGEMENT VALUE PREP ===
// if an input is less than 1, assuming not wanted so we assign 'na' value to disable it.
useTakeProfit   = inpTakeProfit  >= 1 ? inpTakeProfit  : na
useStopLoss     = inpStopLoss    >= 1 ? inpStopLoss    : na
useTrailStop    = inpTrailStop   >= 1 ? inpTrailStop   : na
useTrailOffset  = inpTrailOffset >= 1 ? inpTrailOffset : na

// === STRATEGY - LONG POSITION EXECUTION ===
strategy.entry(id = "Buy", long = true, when = buy[shunt]==1 )// use function or simple condition to decide when to get in
strategy.close(id = "Buy", when = direction[shunt]!=direction[shunt+1])// ...and when to get out

// === STRATEGY - SHORT POSITION EXECUTION ===
strategy.entry(id = "Sell", long = false, when = sell[shunt]==1)
strategy.close(id = "Sell", when = direction[shunt]!=direction[shunt+1])

// === STRATEGY RISK MANAGEMENT EXECUTION ===
// finally, make use of all the earlier values we got prepped
strategy.exit("Exit Buy", from_entry = "Buy", profit = useTakeProfit, loss = useStopLoss, trail_points = useTrailStop, trail_offset = useTrailOffset)
strategy.exit("Exit Sell", from_entry = "Sell", profit = useTakeProfit, loss = useStopLoss, trail_points = useTrailStop, trail_offset = useTrailOffset)

//eof

Lebih banyak

2019 FMZ - Semua hak dilindungi