Langkau tajuk talian

Cara mengautomasikan strategi dagangan manual

Dagangan automatik atau algoritma menawarkan beberapa kelebihan berbanding dagangan manual:

  • Sistem automatik menghapuskan pembuatan keputusan emosi dan melaksanakan dagangan dengan ketepatan, kelajuan dan kecekapan yang lebih tinggi.
  • Algoritma secara konsisten melaksanakan strategi dagangan lanjutan sementara langkah-langkah pengurusan risiko dikuatkuasakan dengan pasti.
  • Algoritma membolehkan pengujian balik strategi menggunakan data sejarah dan mempelbagaikan merentasi pelbagai aset dan pasaran secara serentak.

API cTrader Algo membolehkan pedagang mengautomasikan strategi manual yang kompleks, membolehkan mereka memanfaatkan banyak kelebihan dagangan algoritma. Dalam artikel ini dan video yang menyertainya, anda akan belajar cara mengautomasikan strategi manual yang rumit dan mengubah urutan operasi menjadi algoritma.

Kenal pasti corak strategi manual

Untuk membangunkan algoritma, andaikan kita berdagang secara manual menggunakan corak tukul untuk entri panjang dan corak hanging man untuk entri pendek.

Tukul berlaku semasa aliran menurun dan mencadangkan potensi pembalikan menaik. Corak tukul digunakan untuk mengenal pasti entri beli.

Hanging man muncul semasa aliran menaik dan menunjukkan potensi pembalikan menurun. Corak hanging man digunakan untuk mengenal pasti entri jual.

Bangunkan cBot untuk berdagang strategi manual

Dalam Algo cTrader, mari kita cipta algoritma yang melaksanakan strategi yang diterangkan dalam bahagian sebelumnya.

Klik butang Baharu di bawah tab cBot. Taip Strategi Corak dalam medan nama dan klik Cipta.

Dalam kaedah OnBarClosed(), kita melaksanakan logik untuk strategi kita. Entri kita perlu memenuhi dua syarat ini:

  • Harga penutup sepadan dengan harga tertinggi.
  • Saiz lilin sekurang-kurangnya lima kali lebih besar daripada badan lilin.

Kita mulakan dengan menentukan parameter Volume, StopLoss dan TakeProfit.

1
2
3
4
5
6
7
8
[Parameter(DefaultValue = 1000)]
public double Volume { get; set; }

[Parameter(DefaultValue = 10)]
public double StopLoss { get; set; }

[Parameter(DefaultValue = 10)]
public double TakeProfit { get; set; }

Kemudian kita menulis cebisan kod untuk melaksanakan dagangan beli apabila syarat yang diperlukan dipenuhi.

1
2
3
4
5
if (Bars.Last(0).Close == Bars.Last(0).High &&
            (Bars.Last(0).Close - Bars.Last(0).Open) < (Bars.Last(0).Close - Bars.Last(0).Low) * 0.2)
{
    ExecuteMarketOrder(TradeType.Buy, SymbolName, Volume, InstanceId, StopLoss, TakeProfit);
}

1
2
3
bar = api.Bars.Last(0)
if bar.Close == bar.High and (bar.Close - bar.Open) < (bar.Close - bar.Low) * 0.2:
    api.ExecuteMarketOrder(TradeType.Buy, api.SymbolName, api.Volume, api.InstanceId, api.StopLoss, api.TakeProfit)

Di sebelah bertentangan, ini adalah syarat yang mesti dipenuhi untuk entri jual kita:

  • Harga penutup sepadan dengan harga terendah.
  • Saiz lilin sekurang-kurangnya lima kali lebih besar daripada badan lilin.

Begitu juga, kita menulis cebisan kod untuk melaksanakan dagangan jual apabila syarat yang diperlukan dipenuhi.

1
2
3
4
5
if (Bars.Last(0).Close == Bars.Last(0).Low &&
                (Bars.Last(0).Open - Bars.Last(0).Close) < (Bars.Last(0).High - Bars.Last(0).Close) * 0.2)
{
    ExecuteMarketOrder(TradeType.Sell, SymbolName, Volume, InstanceId, StopLoss, TakeProfit);
}

1
2
if bar.Close == bar.Low and (bar.Open - bar.Close) < (bar.High - bar.Close) * 0.2:
    api.ExecuteMarketOrder(TradeType.Sell, api.SymbolName, api.Volume, api.InstanceId, api.StopLoss, api.TakeProfit)

Anda boleh menyalin kod penuh di bawah:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
using System;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None, AddIndicators = true)]
    public class PatternsStrategy : Robot
    {
        [Parameter(DefaultValue = 1000)]
        public double Volume { get; set; }

        [Parameter(DefaultValue = 10)]
        public double StopLoss { get; set; }

        [Parameter(DefaultValue = 10)]
        public double TakeProfit { get; set; }

        protected override void OnStart()
        {

        }

        protected override void OnBarClosed()
        {
            if (Bars.Last(0).Close == Bars.Last(0).High &&
            (Bars.Last(0).Close - Bars.Last(0).Open) < (Bars.Last(0).Close - Bars.Last(0).Low) * 0.2)
            {
                ExecuteMarketOrder(TradeType.Buy, SymbolName, Volume, InstanceId, StopLoss, TakeProfit);
            }

            if (Bars.Last(0).Close == Bars.Last(0).Low &&
            (Bars.Last(0).Open - Bars.Last(0).Close) < (Bars.Last(0).High - Bars.Last(0).Close) * 0.2)
            {
                ExecuteMarketOrder(TradeType.Sell, SymbolName, Volume, InstanceId, StopLoss, TakeProfit);
            }

        }

        protected override void OnStop()
        {

        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
import clr
clr.AddReference("cAlgo.API")
from cAlgo.API import *
from robot_wrapper import *

class PatternsStrategy():
    def on_start(self):
        pass

    def on_bar_closed(self):
        bar = api.Bars.Last(0)

        if bar.Close == bar.High and (bar.Close - bar.Open) < (bar.Close - bar.Low) * 0.2:
            api.ExecuteMarketOrder(TradeType.Buy, api.SymbolName, api.Volume, api.InstanceId, api.StopLoss, api.TakeProfit)

        if bar.Close == bar.Low and (bar.Open - bar.Close) < (bar.High - bar.Close) * 0.2:
            api.ExecuteMarketOrder(TradeType.Sell, api.SymbolName, api.Volume, api.InstanceId, api.StopLoss, api.TakeProfit)

    def on_stop(self):
        pass

Untuk membina cBot, tekan Ctrl+B atau klik Bina.

Untuk menguji belakang cBot, kita mula-mula menambah satu contoh. Pilih pilihan Secara Tempatan, tentukan parameter pilihan anda dan klik butang Tambah contoh.

Kemudian kita pergi ke tab Ujian Belakang, tentukan tempoh untuk operasi ujian belakang dan mulakan ujian belakang.

Setelah proses ujian belakang selesai, kita boleh memeriksa dagangan. Anda akan melihat bahawa syarat entri dipenuhi sebelum setiap dagangan dimasukkan.

Dengan kejayaan mengautomasikan strategi kita, kita boleh menggunakan cBot untuk membuat dagangan bagi pihak kita.

Laksanakan strategi pembalikan RSI

Dalam contoh kedua kita, kita ingin melaksanakan strategi berdasarkan pembalikan penunjuk Indeks Kekuatan Relatif (RSI). Dalam strategi ini, kita memasuki posisi dengan menjangkakan RSI akan membalikkan arahnya dan mengikuti peraturan ini:

  • Apabila nilai RSI bergerak di bawah ambang beli RSI, kita memasuki posisi beli.
  • Apabila nilai RSI bergerak di atas ambang jual RSI, kita memasuki posisi jual.

Mari kita cipta cBot baharu, masukkan Strategi Pembalikan RSI sebagai namanya dan klik Cipta.

Setelah penyunting kod muncul, tambah System.Linq ke bahagian atas kod sebagai rujukan.

1
using System.Linq;

Mari kita tambah dua parameter yang akan membolehkan kita mengubah suai ambang sebelum kita menjalankan cBot.

1
2
3
4
5
[Parameter(DefaultValue = 30)]
public int BuyLevel { get; set; }

[Parameter(DefaultValue = 70)]
public int SellLevel { get; set; }

Kita mengisytiharkan dan memulakan penunjuk kekuatan relatif kita.

1
2
3
4
5
6
private RelativeStrengthIndex _rsi;

protected override void OnStart()
{
    _rsi = Indicators.RelativeStrengthIndex(Bars.ClosePrices, 14);
}

1
2
3
class RSIReversalStrategy():
    def on_start(self):
        self._rsi = api.Indicators.RelativeStrengthIndex(api.Bars.ClosePrices, 14)

Kemudian kita melaksanakan syarat yang menentukan logik dagangan kita.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
protected override void OnBarClosed()
{

    if (_rsi.Result.LastValue < BuyLevel)
    {
        if (Positions.Count == 0)
            ExecuteMarketOrder(TradeType.Buy, SymbolName, 1000);
        foreach (var position in Positions.Where(p => p.TradeType == TradeType.Sell))
        {
            position.Close();
        }

    }
    else if (_rsi.Result.LastValue > SellLevel)
    {
        if (Positions.Count == 0)
            ExecuteMarketOrder(TradeType.Sell, SymbolName, 1000);
        foreach (var position in Positions.Where(p => p.TradeType == TradeType.Buy))
        {
            position.Close();
        }
    }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
def on_bar_closed(self):
    rsi_value = self._rsi.Result.LastValue

    if rsi_value < api.BuyLevel:
        if api.Positions.Count == 0:
            api.ExecuteMarketOrder(TradeType.Buy, api.SymbolName, 1000)
        for position in api.Positions:
            if position.TradeType == TradeType.Sell:
                position.Close()

    elif rsi_value > api.SellLevel:
        if api.Positions.Count == 0:
            api.ExecuteMarketOrder(TradeType.Sell, api.SymbolName, 1000)
        for position in api.Positions:
            if position.TradeType == TradeType.Buy:
                position.Close()

Anda boleh menyalin kod penuh di bawah:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
using System;
using System.Linq;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None, AddIndicators = true)]
    public class RSIReversalStrategy : Robot
    {
        [Parameter(DefaultValue = 30)]
        public int BuyLevel { get; set; }

        [Parameter(DefaultValue = 70)]
        public int SellLevel { get; set; }

        private RelativeStrengthIndex _rsi;

        protected override void OnStart()
        {
            _rsi = Indicators.RelativeStrengthIndex(Bars.ClosePrices, 14);
        }

        protected override void OnBarClosed()
        {

            if (_rsi.Result.LastValue < BuyLevel)
            {
                if (Positions.Count == 0)
                    ExecuteMarketOrder(TradeType.Buy, SymbolName, 1000);
                foreach (var position in Positions.Where(p => p.TradeType == TradeType.Sell))
                {
                    position.Close();
                }

            }
            else if (_rsi.Result.LastValue > SellLevel)
            {
                if (Positions.Count == 0)
                    ExecuteMarketOrder(TradeType.Sell, SymbolName, 1000);
                foreach (var position in Positions.Where(p => p.TradeType == TradeType.Buy))
                {
                    position.Close();
                }
            }

        }

        protected override void OnStop()
        {

        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import clr
clr.AddReference("cAlgo.API")
from cAlgo.API import *
from robot_wrapper import *

class RSIReversalStrategy():
    def on_start(self):
        self._rsi = api.Indicators.RelativeStrengthIndex(api.Bars.ClosePrices, 14)

    def on_bar_closed(self):
        rsi_value = self._rsi.Result.LastValue

        if rsi_value < api.BuyLevel:
            if api.Positions.Count == 0:
                api.ExecuteMarketOrder(TradeType.Buy, api.SymbolName, 1000)
            for position in api.Positions:
                if position.TradeType == TradeType.Sell:
                    position.Close()

        elif rsi_value > api.SellLevel:
            if api.Positions.Count == 0:
                api.ExecuteMarketOrder(TradeType.Sell, api.SymbolName, 1000)
            for position in api.Positions:
                if position.TradeType == TradeType.Buy:
                    position.Close()

    def on_stop(self):
        pass

Mari kita bina strategi kita, tambah satu contoh dan uji belakang, seperti yang kita lakukan dengan strategi sebelumnya.

Kita boleh memeriksa dan mengkaji semula beberapa dagangan lagi untuk melihat syarat entri dipenuhi sebelum dagangan dimasukkan.

Artikel ini telah menunjukkan cara mengenal pasti strategi manual dan menukarkannya kepada strategi automatik, membolehkan operasi dagangan algoritma.

Image title