Python'da bir alım-satım robotu geliştirme (Bölüm 3): Model tabanlı bir alım-satım algoritmasının uygulanması

Serinin ilk makalesinde veri kümesini yükledik, etiketleri yerleştirdik, veri kümesini zenginleştirdik ve ayrıca veri kümesi etiketleme işlemini gerçekleştirdik. İkinci makalede modelin oluşturulması ve eğitiminin yanı sıra çapraz doğrulama ve torbalama (bagging) uygulamalarına odaklandık. 

Artık modelimiz eğitildiğine ve test edildiğine göre, Python için geliştirilen MetaTrader 5 kütüphanesini kullanarak gerçek alım-satıma başlamanın zamanı geldi. Bu güçlü kütüphane, MetaTrader 5 platformu tarafından sağlanan fonksiyonları ve sınıfları kullanarak doğrudan Python aracılığıyla alım-satımı otomatikleştirmemizi sağlar.

Model tabanlı bir alım-satım algoritmasının uygulanması

Modelimize dayalı bir alım-satım algoritması uygulamak için şu yaklaşımı kullanacağız. Temel algoritma, model tarafından oluşturulan etiketlere karşılık gelen önceden belirlenmiş SL ve TP seviyeleri ile işlem açmaktır. Model enstrüman fiyatının yükseleceğini tahmin ederse, SL ve TP seviyeleri belirlenmiş bir alış pozisyonu açarız. Model enstrüman fiyatının düşeceğini tahmin ederse, benzer SL ve TP parametreleriyle bir satış pozisyonu açarız.

Python için MetaTrader 5 kütüphanesi, işlemlerin açılış ve kapanışını yönetmenin yanı sıra SL ve TP seviyelerini ayarlamak için gerekli araçları sağlar. Bu, model tahminlerine dayalı alım-satımı tamamen otomatikleştirmemize olanak tanır.

Analiz ve eğitimin önceki aşamalarında elde edilen verileri kullanarak, MetaTrader 5 platformunda gerçek zamanlı olarak pozisyon açmak ve kapatmak için sinyaller iletebilir, böylece alım-satım algoritmamızın sürekliliğini ve doğruluğunu sağlayabiliriz.

Dolayısıyla, eğitimli modelimizi Python için geliştirilen MetaTrader 5 kütüphanesiyle entegre etmek, model tahminlerine dayalı olarak işlem yapan, önceden ayarlanmış SL seviyesi ile riskleri yöneten ve TP seviyesi ile karı koruyan verimli ve otomatik bir alım-satım algoritması oluşturmamıza olanak sağlar.

Ortamın, işlem terminalinin ayarlanması ve algoritmanın çalıştırılması

Öncelikle, ortamı ve MetaTrader 5 işlem terminalini ayarlamamız gerekiyor. Bunu yapmak için aşağıdaki adımları izleriz:

pip komutunu kullanarak Python kütüphanelerini yüklüyoruz:

pip install numpy pandas MetaTrader5 scikit-learn xgboost

Terminal referanslarında, terminal çalıştırılabilir dosyasına giden yolumuzu belirtiyoruz:

terminal_path = "C:/Program Files/RoboForex - MetaTrader 5/Arima/terminal64.exe"

Çevrimiçi alım-satımın uygulanması

Çevrimiçi alım-satımı uygulamak için, model tahminimize göre işlemleri açacak online_trading fonksiyonunu ekleyeceğiz.

online_trading fonksiyonu aşağıdaki argümanları alır:

• symbol - işlem yapılacak sembol
• features - tahmin yapmak için kullanılacak özelliklerin listesi
• model - tahmin yapmak için kullanılacak eğitilmiş model

online_trading fonksiyonunun içinde, ilk olarak terminal_path'te belirtilen yolu kullanarak MetaTrader 5 terminaline bağlanırız. Ardından mt5.symbol_info_tick(symbol) fonksiyonunu kullanarak mevcut sembol fiyatlarını alırız.

Sonrasında, iletilen özelliklere dayalı olarak sinyali tahmin etmek için modelimizi kullanırız. Tahmin pozitifse (0.5'ten fazla), bir alış pozisyonu açarız ve tahmin negatifse (0.5'ten az), bir satış pozisyonu açarız.

Ayrıca, riskleri en aza indirmek için her işlem için SL ve TP seviyeleri belirleriz.

Maksimum açık işlem sayısına zaten ulaştıysak (MAX_OPEN_TRADES sabitinde ayarlanır), yenilerini açmayız ve açık işlemlerden biri kapanana kadar bekleriz.

Tahmin yeni bir işlem açmamıza izin vermiyorsa, yeni bir sinyal görünene kadar bekleriz.

Fonksiyonun sonunda, başarılı bir şekilde yerleştirilmişse işlemin gerçekleşmesinin sonucunu veya bir işlem yerleştirilmemişse None geri döndürürüz.

def online_trading(symbol, features, model):
    terminal_path = "C:/Program Files/RoboForex - MetaTrader 5/Arima/terminal64.exe"

    if not mt5.initialize(path=terminal_path):
        print("Error: Failed to connect to MetaTrader 5 terminal")
        return

    open_trades = 0
    e = None
    attempts = 30000

    while True:
        symbol_info = mt5.symbol_info(symbol)
        if symbol_info is not None:
            break
        else:
            print("Error: Instrument not found. Attempt {} of {}".format(_ + 1, attempts))
            time.sleep(5)

    while True:
        price_bid = mt5.symbol_info_tick(symbol).bid
        price_ask = mt5.symbol_info_tick(symbol).ask

        signal = model.predict(features)

        positions_total = mt5.positions_total()

        for _ in range(attempts):
            if positions_total < MAX_OPEN_TRADES and signal[-1] > 0.5:
                request = {
                    "action": mt5.TRADE_ACTION_DEAL,
                    "symbol": symbol,
                    "volume": 0.3,
                    "type": mt5.ORDER_TYPE_BUY,
                    "price": price_ask,
                    "sl": price_ask - 150 * symbol_info.point,
                    "tp": price_ask + 800 * symbol_info.point,
                    "deviation": 20,
                    "magic": 123456,
                    "comment": "Test deal",
                    "type_time": mt5.ORDER_TIME_GTC,
                    "type_filling": mt5.ORDER_FILLING_FOK,
                }
            elif positions_total < MAX_OPEN_TRADES and signal[-1] < 0.5:
                request = {
                    "action": mt5.TRADE_ACTION_DEAL,
                    "symbol": symbol,
                    "volume": 0.3,
                    "type": mt5.ORDER_TYPE_SELL,
                    "price": price_bid,
                    "sl": price_bid + 150 * symbol_info.point,
                    "tp": price_bid - 800 * symbol_info.point,
                    "deviation": 20,
                    "magic": 123456,
                    "comment": "Test deal",
                    "type_time": mt5.ORDER_TIME_GTC,
                    "type_filling": mt5.ORDER_FILLING_FOK,
                }
            else:
                print("No signal to open a position")
                return None

            result = mt5.order_send(request)

            if result.retcode == mt5.TRADE_RETCODE_DONE:
                if signal[-1] < 0.5:
                    print("Buy position opened")
                    open_trades += 1
                elif signal[-1] > 0.5:
                    print("Sell position opened")
                    open_trades += 1
                return result.order
            else:
                print("Error: Trade request not executed, retcode={}. Attempt {}/{}".format(result.retcode, _ + 1, attempts))
                time.sleep(3)

        time.sleep(4000)

def process_symbol(symbol):
    try:
        # Retrieve data for the specified symbol
        raw_data = retrieve_data(symbol)
        if raw_data is None:
            print("No data found for symbol {}".format(symbol))
            return None

        # Augment data
        augmented_data = augment_data(raw_data)

        # Markup data
        marked_data = markup_data(augmented_data.copy(), 'close', 'label')

        # Label data
        labeled_data = label_data(marked_data, symbol)

        # Generate new features
        labeled_data_generate = generate_new_features(labeled_data, num_features=100, random_seed=1)

        # Cluster features by GMM
        labeled_data_clustered = cluster_features_by_gmm(labeled_data_generate, n_components=4)

        # Feature engineering
        labeled_data_engineered = feature_engineering(labeled_data_clustered, n_features_to_select=10)

        # Train XGBoost classifier
        train_data = labeled_data_engineered[labeled_data_engineered.index <= FORWARD]

Çevrimiçi alım-satım algoritmasını başlatma

Çevrimiçi alım-satım algoritmasını başlatmak için, işlem yapılacak sembolü ileterek process_symbol fonksiyonunu çağırırız.

process_symbol fonksiyonu içinde, online_trading fonksiyonunu çağırır, gerekli argümanları iletir ve durdurulana kadar çalışacak bir döngü başlatırız.

Döngünün sonunda, MetaTrader 5 terminalini aşırı yüklememek için 6 saniyelik bir duraklama yaparız.

Algoritma yürütülürken bir hata oluşursa, bir hata mesajı yazdırır ve yürütmeyi iptal ederiz.

Akıllı risk ve düşüş yönetim sistemi

Risk yönetimi, başarılı bir alım-satım stratejisinin temel taşıdır. Yatırımcıların karşılaştığı ana risklerden biri, enstrüman fiyatının önceden belirlenmiş bir seviyenin altına düşmesi durumunda ortaya çıkan düşüş riskidir. Bu riski en aza indirmek için, değişen piyasa koşullarına uyum sağlayabilen etkin bir risk yönetim sistemi gereklidir.

Python için geliştirilen MetaTrader 5 kütüphanesinin araçlarını kullanarak, hesap bakiyesinde düşüş yaşandığında işlem hacmini otomatik olarak azaltan bir sistem geliştireceğiz.

Sistemin temel kuralları:

1. Mevcut hesap bakiyesinin günlük olarak alınması - sistem her gün değişiklikleri analiz etmek için mevcut hesap bakiyesini alacaktır.

2. Bir düşüş sırasında işlem hacminin azaltılması - bakiye bir günde %2'den fazla düşerse, sistem otomatik olarak açılan işlem hacmini %10 oranında azaltacaktır. Bu, riskleri kademeli olarak azaltmak için 0.01 lotluk adımlarla gerçekleşir.

3. Bakiye düşmeye devam ettikçe ek hacim azaltımı - bakiye düşmeye devam ederse, işlem hacmi her gün ek %10 ve 0.01 lot azaltılarak daha fazla anapara koruması sağlanacaktır.

4. Bakiyenin yeniden eski değerine gelmesinden sonra orijinal hacme geri dönme - mevcut hesap bakiyesi bir önceki zirveyi aştığında, sistem otomatik olarak işlem hacmini orijinal değerine geri döndürür. Bu, bir düşüş nedeniyle hacimde geçici bir azalmanın ardından tam alım-satım faaliyetinin geri getirilmesine yardımcı olur.

online_trading fonksiyonuna yeni değişkenler eklendi: account_balance - mevcut bakiyeyi saklamak için, peak_balance - önceki en yüksek bakiye seviyesini saklamak için ve daily_drop - günlük düşüşü izlemek için. Bu değişkenler risk yönetimi mantığını uygulamak için kullanılır.

Örnek kod:

def online_trading(symbol, features, model):
    terminal_path = "C:/Program Files/RoboForex - MetaTrader 5/Arima/terminal64.exe"

    if not mt5.initialize(path=terminal_path):
        print("Error: Failed to connect to MetaTrader 5 terminal")
        return

    open_trades = 0
    e = None
    attempts = 30000

    # Get the current account balance
    account_info = mt5.account_info()
    account_balance = account_info.balance

    # Set the initial volume for opening trades
    volume = 0.3

    # Set the initial peak balance
    peak_balance = account_balance

    while True:
        symbol_info = mt5.symbol_info(symbol)
        if symbol_info is not None:
            break
        else:
            print("Error: Instrument not found. Attempt {} of {}".format(_ + 1, attempts))
            time.sleep(5)

    while True:
        price_bid = mt5.symbol_info_tick(symbol).bid
        price_ask = mt5.symbol_info_tick(symbol).ask

        signal = model.predict(features)

        positions_total = mt5.positions_total()

        # Calculate the daily drop in account balance
        account_info = mt5.account_info()
        current_balance = account_info.balance
        daily_drop = (account_balance - current_balance) / account_balance

        # Reduce the volume for opening trades by 10% with a step of 0.01 lot for each day of daily drop
        if daily_drop > 0.02:
            volume -= 0.01
            volume = max(volume, 0.01)
        elif current_balance > peak_balance:
            volume = 0.3
            peak_balance = current_balance

        for _ in range(attempts):
            if positions_total < MAX_OPEN_TRADES and signal[-1] > 0.5:
                request = {
                    "action": mt5.TRADE_ACTION_DEAL,
                    "symbol": symbol,
                    "volume": volume,
                    "type": mt5.ORDER_TYPE_BUY,
                    "price": price_ask,
                    "sl": price_ask - 150 * symbol_info.point,
                    "tp": price_ask + 800 * symbol_info.point,
                    "deviation": 20,
                    "magic": 123456,
                    "comment": "Test deal",
                    "type_time": mt5.ORDER_TIME_GTC,
                    "type_filling": mt5.ORDER_FILLING_FOK,
                }
            elif positions_total < MAX_OPEN_TRADES and signal[-1] < 0.5:
                request = {
                    "action": mt5.TRADE_ACTION_DEAL,
                    "symbol": symbol,
                    "volume": volume,
                    "type": mt5.ORDER_TYPE_SELL,
                    "price": price_bid,
                    "sl": price_bid + 150 * symbol_info.point,
                    "tp": price_bid - 800 * symbol_info.point,
                    "deviation": 20,
                    "magic": 123456,
                    "comment": "Test deal",
                    "type_time": mt5.ORDER_TIME_GTC,
                    "type_filling": mt5.ORDER_FILLING_FOK,
                }
            else:
                print("No signal to open a position")
                return None

            result = mt5.order_send(request)

            if result.retcode == mt5.TRADE_RETCODE_DONE:
                if signal[-1] < 0.5:
                    print("Buy position opened")
                    open_trades += 1
                elif signal[-1] > 0.5:
                    print("Sell position opened")
                    open_trades += 1
                return result.order
            else:
                print("Error: Trade request not executed, retcode={}. Attempt {}/{}".format(result.retcode, _ + 1, attempts))
                time.sleep(3)

        time.sleep(4000)

Kelly kriterine dayalı lot yönetimi uygulaması

Lot büyüklüğü yönetimi, alım-satımda risk yönetiminin bir diğer önemli yönüdür. Lot kontrolünün popüler yöntemlerinden biri Kelly kriteridir. Kelly Kriteri, kazanma olasılığına ve kazançların kayıplara oranına dayalı olarak en uygun bahis büyüklüğünü belirlemeye yardımcı olan matematiksel bir denklemdir.

Burada Kelly lot büyüklüğü yönetimini risk yönetim sistemimize nasıl uygulayacağımıza bakacağız. Modelin tahmini ile 0.5 arasındaki mesafeyi kazanma olasılığı olarak kullanacağız. Modelin tahmini 0.5'e ne kadar yakınsa, kazanma olasılığı o kadar düşük ve lot büyüklüğü o kadar küçük olmalıdır.

Değiştirilmiş online_trading fonksiyonu:

def online_trading(symbol, features, model):
    terminal_path = "C:/Program Files/RoboForex - MetaTrader 5/Arima/terminal64.exe"

    if not mt5.initialize(path=terminal_path):
        print("Error: Failed to connect to MetaTrader 5 terminal")
        return

    open_trades = 0
    e = None
    attempts = 30000

    # Get the current account balance
    account_info = mt5.account_info()
    account_balance = account_info.balance

    # Set the initial volume for opening trades
    volume = 0.1

    # Set the initial peak balance
    peak_balance = account_balance

    while True:
        symbol_info = mt5.symbol_info(symbol)
        if symbol_info is not None:
            break
        else:
            print("Error: Instrument not found. Attempt {} of {}".format(_ + 1, attempts))
            time.sleep(5)

    while True:
        price_bid = mt5.symbol_info_tick(symbol).bid
        price_ask = mt5.symbol_info_tick(symbol).ask

        signal = model.predict(features)

        positions_total = mt5.positions_total()

        # Calculate the daily drop in account balance
        account_info = mt5.account_info()
        current_balance = account_info.balance
        daily_drop = (account_balance - current_balance) / account_balance

        # Calculate the probability of winning based on the distance between the model's prediction and 0.5
        probability_of_winning = abs(signal[-1] - 0.5) * 2

        # Calculate the optimal volume for opening trades using the Kelly criterion
        optimal_volume = (probability_of_winning - (1 - probability_of_winning) / risk_reward_ratio) / risk_reward_ratio * account_balance / price_ask

        # Reduce the volume for opening trades by 10% with a step of 0.01 lot for each day of daily drop
        if daily_drop > 0.02:
            optimal_volume -= 0.01
            optimal_volume = max(optimal_volume, 0.01)
        elif current_balance > peak_balance:
            optimal_volume = (probability_of_winning - (1 - probability_of_winning) / risk_reward_ratio) / risk_reward_ratio * account_balance / price_ask
            peak_balance = current_balance

        # Set the volume for opening trades
        volume = optimal_volume

        for _ in range(attempts):
            if positions_total < MAX_OPEN_TRADES and signal[-1] > 0.5:
                request = {
                    "action": mt5.TRADE_ACTION_DEAL,
                    "symbol": symbol,
                    "volume": volume,
                    "type": mt5.ORDER_TYPE_BUY,
                    "price": price_ask,
                    "sl": price_ask - 150 * symbol_info.point,
                    "tp": price_ask + 800 * symbol_info.point,
                    "deviation": 20,
                    "magic": 123456,
                    "comment": "Test deal",
                    "type_time": mt5.ORDER_TIME_GTC,
                    "type_filling": mt5.ORDER_FILLING_FOK,
                }
            elif positions_total < MAX_OPEN_TRADES and signal[-1] < 0.5:
                request = {
                    "action": mt5.TRADE_ACTION_DEAL,
                    "symbol": symbol,
                    "volume": volume,
                    "type": mt5.ORDER_TYPE_SELL,
                    "price": price_bid,
                    "sl": price_bid + 150 * symbol_info.point,
                    "tp": price_bid - 800 * symbol_info.point,
                    "deviation": 20,
                    "magic": 123456,
                    "comment": "Test deal",
                    "type_time": mt5.ORDER_TIME_GTC,
                    "type_filling": mt5.ORDER_FILLING_FOK,
                }
            else:
                print("No signal to open a position")
                return None

            result = mt5.order_send(request)

            if result.retcode == mt5.TRADE_RETCODE_DONE:
                if signal[-1] < 0.5:
                    print("Buy position opened")
                    open_trades += 1
                elif signal[-1] > 0.5:
                    print("Sell position opened")
                    open_trades += 1
                return result.order
            else:
                print("Error: Trade request not executed, retcode={}. Attempt {}/{}".format(result.retcode, _ + 1, attempts))
                time.sleep(3)

        time.sleep(4000)

Bu fonksiyona, probability_of_winning ve optimal_volume değişkenlerini ekledim. probability_of_winning, model tahmini ile 0.5 arasındaki mesafenin 2 ile çarpımı olarak hesaplanan kazanma olasılığını saklar. optimal_volume, Kelly kriteri kullanılarak hesaplanan optimum lot büyüklüğünü içerir.

'if daily_drop > 0.05:' bloğunda, optimal_volume değerini 0.01 lotluk adımlarla %10 azaltıyorum. Ayrıca, mevcut hesap bakiyesinin önceki tepe seviyesini aşıp aşmadığını kontrol eden 'elif current_balance > peak_balance:' koşulunu da ekledim. Koşul doğruysa, mevcut bakiye ve kazanç/kayıp oranına göre optimal_volume değerini yeniden hesaplıyorum ve peak_balance’ı güncelliyorum.

Bu Kelly lot büyüklüğü yönetim sistemi, kazanma olasılığına ve kazanç/kayıp oranına göre lot büyüklüğümü otomatik olarak optimize etmeme olanak tanıyacaktır. Bu şekilde karı maksimize edebilir ve düşüş riskini en aza indirebilirim.

Çok dövizli işleyiş ve paralel hesaplama uygulaması

Çoklu dövizli işleyiş, algoritmanın aynı anda birkaç döviz çiftiyle işlem yapmasına olanak tanıyarak riskleri çeşitlendirir. Çiftler içeren 'symbols' listesi aracılığıyla uygulanır.

Paralel hesaplama, görevleri eşzamanlı olarak gerçekleştirerek işi hızlandırır. 'threading' kütüphanesini kullanıyoruz - process_symbol fonksiyonu ile her bir çift için ayrı bir iş parçacığı oluşturulur.

process_symbol çift verilerini indirir, dönüştürür, XGBoost modelini eğitir, test eder ve ardından verileri periyodik olarak güncelleyerek çevrimiçi işlem gerçekleştirir.

'symbols' listesindeki tüm çiftler için iş parçacıkları oluşturulur. Tüm iş parçacıkları tamamlandıktan sonra, program thread.join() kullanarak onları bekler.

Böylece, XGBoost tabanlı yüksek performanslı, çok iş parçacıklı, çok dövizli bir alım-satım sistemi uyguladık.

import threading

def process_symbol(symbol):
    try:
        # Retrieve data for the specified symbol
        raw_data = retrieve_data(symbol)
        if raw_data is None:
            print("No data found for symbol {}".format(symbol))
            return None

        # Augment data
        augmented_data = augment_data(raw_data)

        # Markup data
        marked_data = markup_data(augmented_data.copy(), 'close', 'label')

        # Label data
        labeled_data = label_data(marked_data, symbol)

        # Generate new features
        labeled_data_generate = generate_new_features(labeled_data, num_features=100, random_seed=1)

        # Cluster features by GMM
        labeled_data_clustered = cluster_features_by_gmm(labeled_data_generate, n_components=4)

        # Feature engineering
        labeled_data_engineered = feature_engineering(labeled_data_clustered, n_features_to_select=10)

        # Train XGBoost classifier
        train_data = labeled_data_engineered[labeled_data_engineered.index <= FORWARD]
        test_data = labeled_data_engineered[labeled_data_engineered.index > FORWARD]
        xgb_clf = train_xgboost_classifier(train_data, num_boost_rounds=1000)

        # Test XGBoost classifier
        test_features = test_data.drop(['label', 'labels'], axis=1)
        test_labels = test_data['labels']
        initial_balance = 10000.0
        markup = 0.00001
        test_model(xgb_clf, test_features, test_labels, markup, initial_balance)

        # Online trading
        position_id = None
        while True:
            # Get the last 2000 data points for online trading
            features = raw_data[-6000:].drop(['label', 'labels'], axis=1).values.tolist()

            # Update features every 6 seconds
            time.sleep(6)
            new_data = retrieve_data(symbol)
            if new_data is not None:
                raw_data = pd.concat([raw_data, new_data])
                raw_data = raw_data.dropna()

            # Online trading
            position_id = online_trading(symbol, features, xgb_clf, position_id)

    except Exception as e:
        print("Error processing {} symbol: {}".format(symbol, e))
        return None

symbols = ["EURUSD", "GBPUSD", "USDJPY", "AUDUSD", "USDCAD"]

# Create a list of threads for each symbol
threads = []
for symbol in symbols:
    thread = threading.Thread(target=process_symbol, args=(symbol,))
    thread.start()
    threads.append(thread)

# Wait for all threads to complete
for thread in threads:
    thread.join()

Kodu çalıştırdıktan sonra, farklı iş parçacıklarından üst üste binen ekran çıktısı (yazdırılan ifadeler) ile ilgili bir sorunla karşılaştık. Bu, ekrandaki çıktıyı okunamaz hale getiriyor ve algoritma çalışmasında hata ayıklamayı ve izlemeyi zorlaştırıyor. Bu sorunu çözmek için çok sayıda girişimde bulunmama rağmen, çıktı çakışmasını henüz önleyemedim.

Instruments in terminal: 31Instruments in terminal: 31Instruments in terminal: 31Instruments in terminal: 31Instruments in terminal: 31




No data for symbol USDCAD yet (attempt 1)No data for symbol NZDUSD yet (attempt 1)No data for symbol AUDUSD yet (attempt 1)
No data for symbol GBPUSD yet (attempt 1)


Instruments in terminal: 31Instruments in terminal: 31Instruments in terminal: 31Instruments in terminal: 31



No data for symbol USDCAD yet (attempt 2)No data for symbol AUDUSD yet (attempt 2)No data for symbol GBPUSD yet (attempt 2)


Instruments in terminal: 31Instruments in terminal: 31

Instruments in terminal: 31
No data for symbol GBPUSD yet (attempt 3)
Instruments in terminal: 31

Bu soruna rağmen, algoritmanın kendisi doğru çalışmakta ve işlevlerini yerine getirmektedir. Verileri başarıyla işler, modeli eğitir ve 'symbols' listesinden her döviz çifti için işlem gerçekleştirir. Paralel hesaplama, algoritmanın hızını önemli ölçüde artırmaya ve verimliliğini iyileştirmeye olanak tanır.

Algoritmanın işlemleri doğru şekilde açtığını görüyoruz:

Sistemin potansiyel olarak daha da iyileştirilmesi

Kuantum makine öğrenimi

Şu anda klasik model eğitimi kullanıyoruz, ancak gelecekte doğruluğu ve hızı artırmak için kübitleri kullanarak kuantum makine öğrenimine geçmeyi planlıyoruz. Kuantum bilgisayarlarla ilgili mevcut zorluklara rağmen, özel yazılım ve algoritmalar halihazırda geliştirilmektedir. Kuantum öğrenmeyi araştırmayı ve sistemimize uygulamayı planlıyorum ki bu önemli bir atılım olabilir.

Piyasa geri bildirimi: pekiştirmeli öğrenme

Alım-satım sistemini iyileştirmek için pekiştirmeli öğrenmeyi uygulayabiliriz. Sistem, piyasa ile etkileşime giren bir temsilci olarak hareket edecek, karlı işlemler için ödüller, zarar eden işlemler için ise cezalar alacaktır. Sistem, DQN gibi algoritmaları kullanarak öğrenecek ve adapte olacak, tahminlerini iyileştirecektir.

SL ve TP seçimi için sürü zekası

Sistemimizin verimliliğini artırmak için Parçacık Sürüsü Optimizasyonu (Particle Swarm Optimization, PSO) algoritmasını kullanarak sürü zekasını uygulayabiliriz. Sistem, geçmiş veriler üzerindeki etkinliklerini değerlendirerek çeşitli SL ve TP parametreleri oluşturacaktır. PSO, optimum parametreleri seçmemize yardımcı olacak, uyarlanabilirliği artıracak ve riskleri azaltacaktır.

Sonuç

Alım-satım makine öğrenimi modelimiz veri ön işleme, veri analizi ve XGBoost tipi algoritmalar kullanmaktadır. Ayrıca gürültü ekleme, zaman kaydırma, özellik hesaplama, sınıf dengeleme ve çapraz doğrulama da uyguluyoruz. Test verilerinde doğruluk oranı yaklaşık %60'tır.

Kuantum hesaplama, pekiştirmeli öğrenme ve SL ve TP seçimi için sürü zekası daha sonra uygulanacaktır. Bu, eğitim kalitesini, gerçek veriler üzerindeki verimliliği ve risk yönetimini artıracaktır.

Ancak bir husus var - bu teknolojiler piyasadaki algoritmalar arasında şiddetli bir rekabet yaratacak. Önceden, yatırımcılar birbirleriyle rekabet ediyordu, şimdi ise kimin algoritmasının daha iyi olduğu söz konusu.