Strategi Imbangan Retak Singa


Tarikh penciptaan: 2023-11-02 16:55:00 Akhirnya diubah suai: 2023-11-02 16:55:00
Salin: 0 Bilangan klik: 586
1
fokus pada
1617
Pengikut

Strategi Imbangan Retak Singa

Gambaran keseluruhan

Strategi keseimbangan riak singa adalah strategi perdagangan garis pendek sederhana berdasarkan persilangan rata-rata. Strategi ini menggunakan dua purata bergerak, melakukan lebih banyak apabila purata bergerak cepat melintasi rata-rata bergerak perlahan dari bawah; dan kedudukan yang sama apabila rata-rata bergerak cepat melintasi rata-rata bergerak perlahan dari atas. Nama strategi diambil dari istilah riak singa singa yang popular dalam perdagangan, yang bermaksud menangkap pergerakan kecil harga garis pendek, untuk mendapatkan keuntungan dalam celah rata-rata yang sempit.

Prinsip Strategi

Strategi ini menggunakan dua rata-rata bergerak: rata-rata bergerak cepat kecil MAPeriod dan rata-rata bergerak perlahan bigMAPeriod. Dua rata-rata bergerak membentuk saluran harga, di bawah saluran adalah rata-rata bergerak cepat, di atas saluran adalah rata-rata bergerak perlahan.

Khususnya, strategi ini mulakan dengan mengira rata-rata bergerak cepat (smallMA) dan rata-rata bergerak perlahan (bigMA). Kemudian, kira buyMA di sepanjang saluran, iaitu 100 peratus di bawah (BelowToBuy) % dari rata-rata bergerak perlahan. Apabila buyMA bergerak cepat (smallMA) melintasi buyMA dari arah bawah, buat plus; apabila keuntungan mencapai 1% atau selepas tidak menguntungkan tetapi memegang 7 garis K.

Secara keseluruhannya, strategi ini menangkap kerosakan singa runcing pada garis rata, iaitu peluang untuk menembusi di bawah saluran, dengan tujuan untuk mendapatkan keuntungan dalam jangka pendek. Ia juga menetapkan syarat-syarat berhenti dan berhenti untuk mengawal risiko perdagangan tunggal.

Analisis kelebihan

Strategi ini mempunyai kelebihan berikut:

  1. Konsepnya mudah, mudah difahami dan dilaksanakan. Penggunaan dua persilangan linear adalah strategi penunjuk teknikal yang paling asas.

  2. Strategi ini menggunakan secara langsung fungsi pengembalian yang disediakan oleh TradingView, tanpa perlu melaksanakan tambahan.

  3. Visualisasi yang kuat. Menggunakan TradingView untuk memaparkan titik isyarat perdagangan dan statistik pengesanan semula secara langsung pada carta.

  4. Risiko boleh dikawal. Strategi menetapkan syarat-syarat berhenti dan berhenti yang dapat mengawal kerugian perdagangan tunggal dengan berkesan.

  5. Pengguna boleh menyesuaikan parameter garis rata-rata dan lain-lain petunjuk teknikal mengikut keperluan mereka sendiri, menjadikan strategi lebih sesuai dengan pelbagai jenis dan gaya perdagangan.

Analisis risiko

Strategi ini juga mempunyai risiko:

  1. Ia boleh menghasilkan terlalu banyak isyarat. Strategi dua garis sejajar mudah menghasilkan isyarat yang salah beberapa kali semasa penyusunan.

  2. Kepercayaan pada satu indikator. Hanya menggunakan penyambungan rata-rata untuk membuat keputusan, mengabaikan faktor lain, kualiti isyarat mungkin lebih buruk.

  3. Pengoptimuman parameter sukar. Pengoptimuman kombinasi parameter kitaran rata-rata memerlukan banyak pengiraan, dan tidak mudah untuk mencari parameter terbaik.

  4. Kecacatan pengesanan. Pengesanan strategi sederhana dua garis rata cenderung lebih baik daripada pengesanan cakera keras.

  5. Kesukaran menghentikan kerugian. Menetapkan titik hentian tetap sukar untuk menyesuaikan diri dengan perubahan keadaan.

Arah pengoptimuman

Strategi ini boleh dioptimumkan dengan:

  1. Gabungan dengan isyarat penapis petunjuk lain, seperti jumlah perdagangan, kadar turun naik, dan lain-lain, untuk mengelakkan isyarat tidak sah dalam penyesuaian.

  2. Tambah penilaian berdasarkan trend, mengelakkan perdagangan berlawanan arah. Anda boleh menambah garis purata jangka panjang untuk menilai arah trend.

  3. Menggunakan pembelajaran mesin untuk mencari parameter yang optimum. Menggunakan pengoptimuman parameter bersiri atau algoritma genetik untuk mencari kombinasi parameter yang lebih baik secara automatik.

  4. Menambah strategi penutupan kerugian, seperti menjejaki penutupan, bergerak penutupan, dan lain-lain, menjadikan penutupan kerugian lebih fleksibel.

  5. Optimumkan masa kemasukan. Indikator lain boleh digunakan untuk mengenal pasti masa kemasukan yang lebih berkesan.

  6. Kajian kuantitatif digabungkan untuk mengoptimumkan pengulangan kepada kombinasi parameter, meningkatkan kestabilan.

  7. Membangunkan sistem perdagangan automatik, menggunakan perdagangan berprogram untuk mengoptimumkan kombinasi parameter dan menilai strategi.

ringkaskan

Strategi penyeimbangan celah singa adalah strategi permulaan yang sangat sesuai untuk pembelajaran pemula. Ia menggunakan prinsip simpangan dua persamaan linear, menetapkan peraturan stop loss, dan dapat menangkap pergerakan harga garis pendek. Strategi ini mudah difahami untuk dilaksanakan, mempunyai kesan pengukuran yang baik. Tetapi kesukaran pengoptimumannya besar, kesan langsungnya diragukan.

Kod sumber strategi
/*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 --- ///////////////