[Nekopunis Blog](http://nekopuni.holy.jp/2014/09/python%E5%BC%B7%E5%8C%96%E5%AD%A6%E7%BF%92%EF%BC % 8B% E7% 82% BA% E6% 9B% BF% E3% 83% 88% E3% 83% AC% E3% 83% BC% E3% 83% 89% E6% 88% A6% E7% 95% A5 Inspiriert von% E3% 81% 9D% E3% 81% AE2 /) untersuchte ich den Algorithmushandel mit verbessertem Lernen sowohl für das Hobby als auch für den praktischen Nutzen. Ich bin nicht ganz sicher, was ich schreibe (insbesondere der Code). Meine Hauptverwendung ist als Memo für mich selbst, aber ich würde es begrüßen, wenn es als Referenz für ein schlechtes Umfragematerial verwendet werden könnte.

Referenzmaterial

Ein automatisiertes FX-Handelssystem mit adaptivem Verstärkungslernen [Referenz 1] ← Optimierung durch RRL
Entwurf eines FX-Handelssystems unter Verwendung von Adaptive Reinforcement Learning [Referenz 2] ← Zusammenfassung des obigen Papiers Powerpo
Algorithmushandel mit Q-Learning und Recurrent Reinforcement Learning [Referenz 3] ← Optimal einschließlich Risikomanagement nach Portfolio mit Q-Learning Automatisierung
Ein Multi-Agent-Q-Learning-Framework zur Optimierung von Aktienhandelssystemen [Referenz 4] ← Enthält die von NN prognostizierte Aktienkurs (Verwenden Sie Q-Learning)
Lernen stärken //ir-jp.amazon-adsystem.com/e/ir?t=shimashimao06-22&l=as2&o=9&a=4627826613 "width =" 1 "height =" 1 "border =" 0 "alt =" "style = "Grenze: keine! wichtig; Rand: 0px! wichtig;" /> [Referenz 5]
LEISTUNGSFUNKTIONEN UND VERSTÄRKUNGSLERNEN FÜR HANDELSSYSTEME UND PORTFOLIOS [Referenz 6]
[Lern- und neuronales Netzwerk (Reihe für elektronische Informations- und Kommunikationstechnik)](http://www.amazon.co.jp/gp/product/4627702914/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=247&creative=1211&creativeASIN=4627702914&linkCode= -22) [Referenz 7]

Übersicht über die Umfrage

Bedeutung der Verwendung von Verstärkungslernen (siehe Referenz 4)

Der Unterschied zwischen verbessertem Lernen und überwachtem Lernen ist wie folgt.

Die Stärkung des Lernens zielt darauf ab, die erwarteten Belohnungen der Umwelt durch Optimierung der Richtlinien zu maximieren
Überwachtes Lernen zielt darauf ab, Vorhersagefehler für Lehrerdaten zu reduzieren

Beim überwachten Lernen werden die Bedingungen ohne eine einheitliche Handelspolitik optimiert. Auf der anderen Seite ermöglicht intensives Lernen die Erstellung von Algorithmen einschließlich der Umgebung und der Richtlinien, sodass davon ausgegangen wird, dass die Effektivität der Verwendung von verbessertem Lernen hoch ist.

Unterschied zwischen Value Function RL und Direct RL

■Value Function RL Der Aktionswert wird nach Status oder Statusaktionspaar zugewiesen. Basierend auf diesem Wert optimieren wir die Richtlinie (die Aktionsrichtlinie, die ergriffen werden muss, wenn ein bestimmter Status erreicht wird). Dies maximiert die langfristig erwarteten Belohnungen. Q-Learning wird hier klassifiziert. Einzelheiten zum Q-Learning finden Sie unter Referenz 5. .

■Direct RL Wir werden die Belohnungsfunktion (Anzahl der Werte) direkt basierend auf der Erfahrung (beobachteter Wert) aus der Umgebung anpassen. Im Gegensatz zum Q-Learning ist keine Q-Tabelle erforderlich, sodass der Umfang der zeitlichen / räumlichen Berechnung gering ist. Die Maximierung der erwarteten Belohnungen wird jedoch kurzfristig sein. Recurrent Reinforcement Learning (RRL) wird hier kategorisiert. Weitere Informationen zu RRL Referenz 5 img src = "http://ir-jp.amazon-adsystem.com/e/ir?t=shimashimao06-22&l=as2&o=9&a=4627826613" width = "1" height = "1" border = "0" alt Bitte beziehen Sie sich auf = "" style = "border: none! Important; margin: 0px! Important;" />. (Dieses Mal schreibe ich den Code mit dieser RRL.)

RRL Financial Trading Framework

Agent: RRL-trader
Zustand: Der Zustand des Marktes, wie er durch technische Indikatoren oder vergangene Renditen definiert ist
Belohnung: Belohnung mit Risiken und Gebühren zwischen t und t + 1
Action: trading signal(buy/sell/short/long/neutral/hold)

Agentenbewertung

Verwenden Sie das Differential Sharpe Ratio (DSR). Wird beim Aktualisieren des Gewichts verwendet.

Vorsichtsmaßnahmen für den tatsächlichen Betrieb

Verlustschnitt
Präferenz für Risiko
Systemausfall, wenn abnormales Verhalten bestätigt wird

Algorithmus (siehe Referenz 1)

[Positionsbestimmung zum Zeitpunkt t (lang oder kurz)]

F_t=sign(\sum_{i=0}^{M}w_{i,t}r_{t-i}+w_{M+1,t}F_{t-1}+v_t) F_t ∈ [-1,1]; (short=-1, long=1) w_t: weight vector v_t: threshold of the neural network $ r_t $: $ p_t --p_ {t-1} $ (Rückkehr in Zeitreihen)

Die Form der Formel entspricht einem einfachen einschichtigen neuronalen Netzwerk. Tatsächlich wird die Methode des neuronalen Netzwerks angewendet, und der Schwellenwert $ v_t $ ist zur Optimierung auch im Gewichtsvektor enthalten.

[Gewinn zum Zeitpunkt T]

P_t=\sum_{t=0}^{T}R_t R_t:=F_{t-1}r_t-δ|F_t-F_{t-1}| δ: Transaktionskosten

Es wird davon ausgegangen, dass bei jeder Transaktion nur eine Einheit gehandelt wird.

[Optimierter Bewertungswert]

■sharpe ratio \hat{S}(t):=\frac{A_t}{B_t} A_t=A_{t-1}+η(R_t-A_{t-1}), A_0=0 B_t=B_{t-1}+η(R_t^2-B_{t-1}), B_0=0 η: adaptation parameter

■Differential Sharpe Ratio(DSR) Eine verbesserte Version des gleitenden Durchschnitts der Sharpe Ratio für das Online-Lernen. DSR ist leichter in der Berechnung und konvergiert schneller (wie es scheint). Ueno $ \ hat {S} $ wird von Taylor um η = 0 erweitert und der erste Term wird erworben. D_t:=\frac{d\hat{S}}{dη}|_{η=0}

=\frac{B_{t-1}\Delta A_t-\frac{1}{2}A_{t-1}\Delta B_t}{(B_{t-1}-A_{t-1}^2)^\frac{3}{2}} \Delta A_t=R_t-A_{t-1} \Delta B_t=R_t^2-B_{t-1}

Betrachten Sie $ D_t $ als sofortiges Leistungsmaß und aktualisieren Sie das Gewicht, um es zu maximieren.

[Gewicht aktualisieren]

w_{i,t}=w_{i,t-1}+\rho \Delta w_{i,t} \Delta w_{i,t}=\frac{dD_t}{dw_i} 　　　\approx \frac{dD_t}{dR_t}{ \frac{dR_t}{dF_t}\frac{dF_t}{dw_{i,t}} + \frac{dR_t}{dF_{t-1}}\frac{dF_{t-1}}{dw_{i,t-1}}}

\frac{dF_t}{dw_{i,t}}\approx\frac{\partial F_t}{\partial w_{i,t}}+\frac{\partial F_t}{\partial F_{t-1}}\frac{dF_{t-1}}{dw_{i,t-1}}

\frac{dD_t}{dR_t}=\frac{B_{t-1}-A_{t-1}R_t}{(B_{t-1}-A_{t-1}^2)^{3/2}} \frac{dR_t}{dF_t}=-\delta \frac{dR_t}{dF_{t-1}}=r_t-\delta

[Verlustunterbrechung, Signaleinstellungsschwelle, Beurteilung von Systemanomalien]

Es gibt eine Anweisung, dass es als Parameter festgelegt werden soll, aber es gibt keine spezifische Beschreibung. Es scheint keine andere Wahl zu geben, als einen empirischen Wert festzulegen. ..

Referenzcode

Die Vorzeichenfunktion wird einmal als tanh berechnet und signalisiert, je nachdem, ob $ F_t $ größer als 0 ist oder nicht. Funktionen wie Verlustreduzierung werden nicht geschrieben. Es ist ein ziemlich verdächtiger Code, obwohl ich ihn selbst sage. Bitte beachten Sie als Referenz.

`python`


# coding: utf-8

import os
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from math import tanh, copysign

class RRLAgentForFX:
    TRADING_COST = 0.003
    EPS = 1e-6
        
    def __init__(self,M,rho=0.01,eta=0.1,bias=1.0):
        np.random.seed(555)
        self.M = M # number of lags
        self.weights = np.zeros(self.M+3,dtype=np.float64)
        self.bias = bias # bias term
        self.rho = rho
        self.eta = eta
        self.price_diff = np.zeros(self.M+1) # r_t
        
        self.pre_price = None
        self.pre_signal = 0
        
        self.pre_A = 0.0
        self.pre_B = 0.0
        self.pre_gradient_F = 0.0
        
        # result store
        self.signal_store = []
        self.profit_store = []
        self.dsr_store = []
        self.sr_store = []
        self.cumulative_profit = 0.0
        
    def train_online(self, price):
        self.calculate_price_diff(price)
        signal, self.F_t_value = self.select_signal()
        print "signal",signal
        self.calculate_return(signal)
        self.update_parameters()
        self.pre_price = price
        self.pre_signal = signal
        
        # store result
        self.signal_store.append(signal)
                    
    def calculate_price_diff(self,price):
        r = price - self.pre_price if self.pre_price is not None else 0
        self.price_diff[:self.M] = self.price_diff[1:]
        self.price_diff[self.M] = r
        
    def calculate_return(self,signal):
        R_t = self.pre_signal*self.price_diff[-1]
        R_t -= self.TRADING_COST*abs(signal - self.pre_signal)
        self.return_t = R_t
        
        self.cumulative_profit += R_t
        self.profit_store.append(self.cumulative_profit)
            
    def select_signal(self):
        values_sum = (self.weights[:self.M+1]*self.price_diff).sum()
        values_sum += self.weights[-2]*self.pre_signal
        values_sum += self.bias*self.weights[-1]
        
        F_t_value = tanh(values_sum)
        return copysign(1, F_t_value ), F_t_value
                                            
    def update_parameters(self):
        # update weight
        self.weights += self.rho*self.calculate_gradient_weights()
        print "weight",self.weights

        # update moment R_t
        self.update_R_moment()

    def calculate_gradient_weights(self):
        """ differentiate between D_t and w_t """
        denominator = self.pre_B-self.pre_A**2
        if denominator!=0:
            diff_D_R = self.pre_B-self.pre_A*self.return_t
            diff_D_R /= (denominator)**1.5
        else:
            diff_D_R = 0
        
        gradient_F = self.calculate_gradient_F()
        print "gradient_F",gradient_F

        #diff_R_F = -self.TRADING_COST
        #diff_R_F_{t-1} = self.price_diff[-1] - self.TRADING_COST
        delta_weights = -self.TRADING_COST*gradient_F
        delta_weights += ( self.price_diff[-1] - self.TRADING_COST) \
                                                    *self.pre_gradient_F
        delta_weights *= diff_D_R
        self.pre_gradient_F = gradient_F
        return delta_weights
        
    def calculate_gradient_F(self):
        """ differentiate between F_t and w_t """
        diff_tnah = 1-self.F_t_value**2

        diff_F_w = diff_tnah*( np.r_[ self.price_diff, self.pre_signal, self.bias ] )
        diff_F_F = diff_tnah*self.weights[-2]

        return diff_F_w + diff_F_F*self.pre_gradient_F

    def update_R_moment(self):
        delta_A = self.return_t - self.pre_A
        delta_B = self.return_t**2 - self.pre_B
        A_t = self.pre_A + self.eta*delta_A # A_t. first moment of R_t.
        B_t = self.pre_B + self.eta*delta_B # B_t. second moment of R_t.
        self.sr_store.append(A_t/B_t)
        self.calculate_dsr(delta_A, delta_B)
        
        self.pre_A = A_t
        self.pre_B = B_t

    def calculate_dsr(self,delta_A,delta_B):
        dsr = self.pre_B*delta_A - 0.5*self.pre_A*delta_B
        dsr /= (self.pre_B-self.pre_A**2)**1.5
        self.dsr_store.append(dsr)

if __name__=='__main__':
    M = 8
    fx_agent = RRLAgentForFX(M,rho=0.01,eta=0.01,bias=0.25)
    
    ifname = os.getcwd()+'/input/quote.csv'
    data = pd.read_csv(ifname)
    train_data = data.ix[:3000,'USD']
    
    for price in train_data.values:
        fx_agent.train_online(price)

Experiment

Ich habe die CSV-Datei mit den Datums- und Zeitdaten des Wechselkurses (/ Yen) von der Seite Historische Daten der Mizuho Bank heruntergeladen und verwendet. .. Ich habe ab dem 1. April 2002 USD / Yen verwendet und anhand von 3.000 Daten gelernt.

Versuchsergebnis

USD / Yen-Kurs

Kumulierter Gewinn (beim Kauf von nur 1 Einheit pro Tag)

DSR

Kommentar

Das Ergebnis hängt von den Werten von ρ und η ab. Es ist zu instabil. .. Ich möchte den Code aktualisieren, sobald ich den Fehler bemerke. Wenn Sie etwas Seltsames bemerken, wäre es sehr dankbar, wenn Sie einen Kommentar abgeben könnten.

[PYTHON] Ich untersuchte den stärkenden Lernalgorithmus des Algorithmushandels