Ana içeriğe geç

Manuel işlem stratejisini otomatikleştirme

Otomatik veya algoritmik işlem yapma, manuel işlem yapmaya göre çeşitli avantajlar sunar:

  • Otomatik sistemler, duygusal karar almayı ortadan kaldırır ve işlemleri artırılmış hassasiyet, hız ve verimlilikle gerçekleştirir.
  • Algoritmalar, risk yönetimi önlemleri güvenilir bir şekilde uygulanırken gelişmiş işlem stratejilerini tutarlı bir şekilde uygular.
  • Algoritmalar, geçmiş verileri kullanarak stratejileri geriye dönük test etmeyi ve aynı anda birden fazla varlık ve piyasada çeşitlendirme yapmayı sağlar.

cTrader Algo API, trader'lara karmaşık manuel stratejileri otomatikleştirme gücü verir ve böylece algoritmik işlem yapmanın birçok avantajından yararlanmalarını sağlar. Bu makalede ve beraberindeki videosunda, karmaşık manuel stratejileri nasıl otomatikleştireceğinizi ve işlem dizilerini algoritmalara nasıl dönüştüreceğinizi öğreneceksiniz.

Manuel strateji modellerini belirleme

Bir algoritma geliştirmek için, uzun girişler için hammer modelini ve kısa girişler için hanging man modelini manuel olarak işlem yaptığımızı varsayalım.

Bir hammer, bir düşüş trendi sırasında oluşur ve potansiyel bir yükseliş dönüşünü işaret eder. Çekiç formasyonu alış girişlerini belirlemek için kullanılır.

Bir hanging man yükseliş trendi sırasında ortaya çıkar ve potansiyel bir düşüş yönlü dönüşü işaret eder. hanging man formasyonu satış girişlerini belirlemek için kullanılır.

Manuel stratejiyi işlem yapmak için bir cBot geliştirin

cTrader Algo'da, önceki bölümde açıklanan stratejiyi uygulayan bir algoritma oluşturalım.

cBot sekmesinin altındaki Yeni düğmesine tıklayın. Ad alanına Formasyon Stratejisi yazın ve Oluştur'a tıklayın.

OnBarClosed() metodunda, stratejimizin mantığını uygularız. Girişlerimiz şu iki koşulu karşılamalıdır:

  • Kapanış fiyatı yüksek fiyatla eşleşir.
  • Mum boyutu, mum gövdesinden en az beş kat daha büyüktür.

Volume, StopLoss ve TakeProfit parametrelerini tanımlayarak başlarız.

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; }

Ardından, gerekli koşullar karşılandığında bir alış işlemi gerçekleştirmek için bir kod parçacığı yazarız.

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)

Karşı tarafta, satış girişlerimiz için karşılanması gereken koşullar şunlardır:

  • Kapanış fiyatı düşük fiyatla eşleşir.
  • Mum boyutu, mum gövdesinden en az beş kat daha büyüktür.

Benzer şekilde, gerekli koşullar karşılandığında bir satış işlemi gerçekleştirmek için bir kod parçacığı yazarız.

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)

Aşağıdaki kodun tamamını kopyalayabilirsiniz:

 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

cBot'u derlemek için Ctrl+B tuşlarına basın veya Derle'ye tıklayın.

cBot'u geriye dönük test etmek için önce bir örnek ekleriz. Yerel seçeneğini belirleyin, tercih ettiğiniz parametreleri belirtin ve Örnek ekle düğmesine tıklayın.

Ardından Geriye Dönük Test sekmesine gider, geriye dönük test işlemi için bir dönem belirtir ve geriye dönük testi başlatırız.

Geriye dönük test süreci tamamlandığında, işlemleri inceleyebiliriz. Her işlem girilmeden hemen önce giriş koşullarının karşılandığını göreceksiniz.

Stratejimizin başarılı otomasyonuyla, cBot'u adımıza işlemler yapması için kullanabiliriz.

RSI dönüş stratejisini uygulayın

İkinci örneğimizde, Relative Strength Index (RSI) gösterge dönüşüne dayalı bir strateji uygulamak istiyoruz. Bu stratejide, RSI'ın yönünü değiştirmesini bekleyerek pozisyonlara gireriz ve şu kuralları takip ederiz:

  • RSI değeri, RSI alış eşiğinin altına düştüğünde bir alış pozisyonuna gireriz.
  • RSI değeri, RSI satış eşiğinin üzerine çıktığında bir satış pozisyonuna gireriz.

Yeni bir cBot oluşturalım, adını RSI Dönüş Stratejisi olarak girelim ve Oluştur'a tıklayalım.

Kod düzenleyici göründüğünde, System.Linq'i kodun en üstüne referans olarak ekleyin.

1
using System.Linq;

cBot'u çalıştırmadan önce eşikleri değiştirmemize olanak tanıyacak iki parametre ekleyelim.

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

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

Göreceli güç göstergemizi tanımlar ve başlatırız.

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)

Ardından, işlem mantığımızı tanımlayan koşulları uygularız.

 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()

Aşağıdaki kodun tamamını kopyalayabilirsiniz:

 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

Önceki stratejide yaptığımız gibi, stratejimizi derleyelim, bir örnek ekleyelim ve geriye dönük test edelim.

Bir işlem girilmeden hemen önce giriş koşullarının karşılandığını görmek için bazı işlemleri tekrar inceleyebilir ve gözden geçirebiliriz.

Bu makale, manuel bir stratejiyi nasıl belirleyeceğimizi ve algoritmik işlem yapma işlemlerine olanak tanıyarak onu otomatik bir stratejiye nasıl dönüştüreceğimizi göstermiştir.

Image title