Strategi Keseimbangan Celah Singa

Penulis:ChaoZhang, Tanggal: 2023-11-02 16:55:00
Tag:

img

Gambaran umum

Strategi keseimbangan celah singa adalah strategi perdagangan jangka pendek yang sederhana berdasarkan crossover rata-rata bergerak. Strategi ini terutama menggunakan dua rata-rata bergerak - ketika MA cepat melintasi di atas MA lambat dari bawah, pergi panjang; ketika MA cepat melintasi di bawah MA lambat dari atas, tutup posisi.

Logika Strategi

Strategi ini menggunakan dua rata-rata bergerak: MA cepat (smallMAPeriod) dan MA lambat (bigMAPeriod). Dua MA membentuk saluran harga, dengan MA cepat sebagai dasar saluran dan MA lambat sebagai langit-langit saluran.

Secara khusus, strategi pertama menghitung MA cepat (smallMA) dan MA lambat (bigMA). Kemudian menghitung garis beli (buyMA), yang adalah (100 - persenBelowToBuy) % dari MA lambat. Ketika MA cepat melintasi di atas garis beli ke atas, pergi panjang; ketika mencapai keuntungan 1% atau memegang 7 bar tanpa keuntungan, tutup posisi.

Singkatnya, strategi ini bertujuan untuk menangkap Lion Fissure antara MAs untuk keuntungan jangka pendek.

Analisis Keuntungan

Strategi ini memiliki keuntungan berikut:

  1. Konsep sederhana yang mudah dipahami dan diimplementasikan.

  2. Strategi ini secara langsung menggunakan backtester built-in TradingView tanpa implementasi tambahan.

  3. Visualisasi yang kuat. TradingView dapat langsung menampilkan sinyal perdagangan dan data statistik pada grafik.

  4. Risiko yang dapat dikendalikan. Strategi menetapkan kondisi mengambil keuntungan dan menghentikan kerugian untuk secara efektif mengendalikan kerugian per perdagangan.

  5. Pengguna dapat menyesuaikan parameter MA dan indikator lainnya agar sesuai dengan produk dan gaya perdagangan yang berbeda.

Analisis Risiko

Strategi ini juga memiliki risiko berikut:

  1. Sinyal yang berpotensi berlebihan. Strategi MA ganda cenderung menghasilkan sinyal palsu selama konsolidasi.

  2. Keandalan indikator tunggal: Menggunakan hanya MA silang mengabaikan faktor lain, berpotensi menghasilkan kualitas sinyal yang buruk.

  3. Optimasi parameter yang sulit. Menemukan kombinasi MA yang optimal membutuhkan perhitungan ekstensif.

  4. Backtest bias. Strategi dual MA sederhana sering tampil lebih baik dalam backtest daripada perdagangan langsung.

  5. Stop loss yang sulit. Tingkat stop loss tetap mungkin tidak dapat beradaptasi dengan perubahan kondisi pasar.

Arahan Optimasi

Strategi dapat ditingkatkan dari aspek berikut:

  1. Tambahkan filter lain seperti volume dan volatilitas untuk menghindari sinyal yang tidak efektif selama konsolidasi.

  2. Menggabungkan bias tren untuk menghindari perdagangan kontra-tren. MA periode yang lebih lama dapat ditambahkan untuk menentukan arah tren.

  3. Gunakan pembelajaran mesin untuk menemukan parameter optimal, seperti optimasi parameter berurutan atau algoritma genetik.

  4. Meningkatkan strategi stop loss, seperti trailing stop loss dan adaptive stop loss untuk fleksibilitas yang lebih baik.

  5. Mengoptimalkan waktu masuk menggunakan indikator lain untuk mengidentifikasi titik masuk dengan probabilitas yang lebih tinggi.

  6. Melakukan penelitian kuantitatif dan backtesting untuk meningkatkan stabilitas set parameter yang dioptimalkan.

  7. Mengembangkan sistem perdagangan otomatis untuk secara sistematis mengoptimalkan dan mengevaluasi kombinasi parameter.

Kesimpulan

Strategi Lion Fissure Balance adalah strategi pemula yang sangat baik untuk dipelajari. Strategi ini menerapkan logika crossover MA ganda yang sederhana dan menetapkan aturan mengambil keuntungan dan menghentikan kerugian untuk menangkap perubahan harga jangka pendek. Strategi ini mudah dipahami dan diimplementasikan, dan menunjukkan hasil backtest yang baik. Namun, strategi ini mengalami kesulitan pengoptimalan dan kinerja langsung yang dipertanyakan. Kita dapat meningkatkan strategi dengan menggabungkan indikator lain, mengoptimalkan parameter, dan mengembangkan sistem perdagangan otomatis. Secara keseluruhan, strategi Lion Fissure Balance menyediakan platform pembelajaran yang bagus untuk pemula perdagangan kuantitatif.


/*backtest
start: 2023-10-02 00:00:00
end: 2023-11-01 00:00:00
period: 1h
basePeriod: 15m
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/
// © TraderHalai
// This script was born out of my quest to be able to display strategy back test statistics on charts to allow for easier backtesting on devices that do not natively support backtest engine (such as mobile phones, when I am backtesting from away from my computer). There are already a few good ones on TradingView, but most / many are too complicated for my needs.
//
//Found an excellent display backtest engine by 'The Art of Trading'. This script is a snippet of his hard work, with some very minor tweaks and changes. Much respect to the original author.
//
//Full credit to the original author of this script. It can be found here: https://www.tradingview.com/script/t776tkZv-Hammers-Stars-Strategy/?offer_id=10&aff_id=15271
//
// This script can be copied and airlifted onto existing strategy scripts of your own, and integrates out of the box without implementation of additional functions. I've also added Max Runup, Average Win and Average Loss per trade to the orignal script.
//
//Will look to add in more performance metrics in future, as I further develop this script.
//
//Feel free to use this display panel in your scripts and strategies.

//Thanks and enjoy! :)
//@version=5
// strategy("Strategy BackTest Display Statistics - TraderHalai", overlay=true, default_qty_value= 5, default_qty_type = strategy.percent_of_equity, initial_capital=10000,  commission_type=strategy.commission.percent, commission_value=0.1)

//DEMO basic strategy - Use your own strategy here -  Jaws Mean Reversion from my profile used here
source = input(title = "Source", defval = close)
smallMAPeriod = input(title = "Small Moving Average", defval = 2)
bigMAPeriod = input(title = "Big Moving Average", defval = 8)
percentBelowToBuy = input(title = "Percent below to buy %", defval = 1)

smallMA = ta.sma(source, smallMAPeriod)
bigMA =  ta.sma(source, bigMAPeriod) 
buyMA = ((100 - percentBelowToBuy) / 100) * ta.sma(source, bigMAPeriod)[0]

buy = ta.crossunder(smallMA, buyMA)
if(buy)
    strategy.entry("BUY", strategy.long)

if(strategy.openprofit >= strategy.position_avg_price * 0.01) // 1% profit target
    strategy.close("BUY")

if(ta.barssince(buy) >= 7) //Timed Exit, if you fail to make 1 percent in 7 candles.
    strategy.close("BUY")
    
///////////////////////////// --- BEGIN TESTER CODE --- ////////////////////////
// COPY below into your strategy to enable display
////////////////////////////////////////////////////////////////////////////////

// strategy.initial_capital = 50000
// // Declare performance tracking variables
// drawTester = input.bool(true, "Draw Tester")
// var balance = strategy.initial_capital
// var drawdown = 0.0
// var maxDrawdown = 0.0
// var maxBalance = 0.0
// var totalWins = 0
// var totalLoss = 0

// // Prepare stats table
// var table testTable = table.new(position.top_right, 5, 2, border_width=1)
// f_fillCell(_table, _column, _row, _title, _value, _bgcolor, _txtcolor) =>
//     _cellText = _title + "\n" + _value
//     table.cell(_table, _column, _row, _cellText, bgcolor=_bgcolor, text_color=_txtcolor)
    
// // Custom function to truncate (cut) excess decimal places
// truncate(_number, _decimalPlaces) =>
//     _factor = math.pow(10, _decimalPlaces)
//     int(_number * _factor) / _factor
    
// // Draw stats table
// var bgcolor = color.new(color.black,0)
// if drawTester
//     if barstate.islastconfirmedhistory
//         // Update table
//         dollarReturn = strategy.netprofit
//         f_fillCell(testTable, 0, 0, "Total Trades:", str.tostring(strategy.closedtrades), bgcolor, color.white)
//         f_fillCell(testTable, 0, 1, "Win Rate:", str.tostring(truncate((strategy.wintrades/strategy.closedtrades)*100,2)) + "%", bgcolor, color.white)
//         f_fillCell(testTable, 1, 0, "Starting:", "$" + str.tostring(strategy.initial_capital), bgcolor, color.white)
//         f_fillCell(testTable, 1, 1, "Ending:", "$" + str.tostring(truncate(strategy.initial_capital + strategy.netprofit,2)), bgcolor, color.white)
//         f_fillCell(testTable, 2, 0, "Avg Win:", "$"+ str.tostring(truncate(strategy.grossprofit / strategy.wintrades, 2)), bgcolor, color.white)
//         f_fillCell(testTable, 2, 1, "Avg Loss:", "$"+ str.tostring(truncate(strategy.grossloss / strategy.losstrades, 2)), bgcolor, color.white)
//         f_fillCell(testTable, 3, 0, "Profit Factor:", str.tostring(truncate(strategy.grossprofit / strategy.grossloss,2)), strategy.grossprofit > strategy.grossloss ? color.green : color.red, color.white)
//         f_fillCell(testTable, 3, 1, "Max Runup:",  str.tostring(truncate(strategy.max_runup, 2 )), bgcolor, color.white)
//         f_fillCell(testTable, 4, 0, "Return:", (dollarReturn > 0 ? "+" : "") + str.tostring(truncate((dollarReturn / strategy.initial_capital)*100,2)) + "%", dollarReturn > 0 ? color.green : color.red, color.white)
//         f_fillCell(testTable, 4, 1, "Max DD:", str.tostring(truncate((strategy.max_drawdown / strategy.equity) * 100 ,2)) + "%", color.red, color.white)
// // --- END TESTER CODE --- ///////////////

Lebih banyak