Gibt es eine Funktion für folgende Spaltenerstellung?

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Antworten
Bayne
User
Beiträge: 40
Registriert: Freitag 31. Mai 2019, 16:28

Hey,

ich habe bisher meine datascience features mit lambda und map() erstellen können.
Nun benötige ich jedoch eine komplexere Target-label -Spalte in meinem Neuronalen Netz...
Ich habe den Code soweit es ging aus meinem C++ beispiel in Python übernommen, und ich hoffe es ist einigermaßen verständlich was ich suche:

nämlich eine schnellere Umsetzung des ganzen ohne derartige for loops, denn bei 126.614 Zeilen an Börsenkurs-Schlusspreise ("Close") und Höchst und Tiefkursen ("High","Low")
dauert das ganze ziemlich lange... gibt es da vielleicht eine schnellere Lösung?

Hier der Code wie ich in aus C++ zu Python übernahm:

Code: Alles auswählen

import pandas as pd 


Target_tp_Long = 0.0400
Target_sl_Long = 0.0200
Target_tp_Short = 0.0400
Target_sl_Short = 0.0200
FUTURE_PERIOD_PREDICT=12    

df = pd.read_csv("Training Data/EURUSD1999-2019.csv",delimiter= ",")

# wir brauchen nur folgende 3 Spalten aus dem CSV
#df["Close"]
#df["Low"]
#df["High"]   

Y = pd.DataFrame()
Y["target"] = df["Close"]
print(Y["target"])
for i in range(len(df)-FUTURE_PERIOD_PREDICT):
    
    #print(i)
    
    Long_sl=False
    Short_sl =False

    for j in range(1,FUTURE_PERIOD_PREDICT):
        #print(j)
        if Long_sl ==True:
            print("Long_sl",Long_sl, " j = ",j-i)
        if Short_sl ==True:
            print("Short_sl",Short_sl, " j = ",j-i)
            
        # gewünschter Stoploss long: wenn wert diesen wert unterschreitet, kann man die Kauf-position vergessen    
        if ((df["Close"].iloc[i] - df["Low"].iloc[i+j]) > Target_sl_Long):
                Long_sl = True
                print("Long_sl",Long_sl, " j = ",j)
        # gewünschter Stoploss Short: wenn wert diesen wert unterschreitet, kann man die Leerverkauf-position vergessen 
        if (( df["High"].iloc[i+j] - df["Close"].iloc[i]) > Target_sl_Short):
                Short_sl = True
                print("Short_sl",Long_sl, " j = ",j)
                
        # wenn wert innerhalb der nächsten FUTURE_PERIOD_PREDICT den gewünschten Long TakeProfit übersteigt ist es einen Kauf wert :)
        if( ( df["High"].iloc[i+j] - df["Close"].iloc[i]) >Target_tp_Long and Long_sl ==False ):
            Y["target"].iloc[i]=1
            print("Target = 1,  i=",i)
            print( (df["High"].iloc[i+j] - df["Close"].iloc[i])," > ",Target_tp_Long ,"and Long_sl == ",Long_sl) 
            break
        # wenn wert innerhalb der nächsten FUTURE_PERIOD_PREDICT den gewünschten Short TakeProfit durchfällt ist es einen LeerVerkauf wert :)    
        elif ( (df["Close"].iloc[i] - df["Low"].iloc[i+j] ) > Target_tp_Short and Short_sl==False):
            Y["target"].iloc[i]=-1
            print("Target = -1,  i=",i)
            print( (df["Close"].iloc[i] - df["Low"].iloc[i+j] )," > ",Target_tp_Short, "and Short_sl == ",Short_sl) 
            break
        # Weder Kauf- noch Verkaufsposition lohnen sich, wir tun also nichts -> 0    
        elif (j == FUTURE_PERIOD_PREDICT -1): 
            Y["target"].iloc[i]=0
            
            
            
    if Y["target"].iloc[i] != (0 or 1 or -1):
        print("fehler im algorythmus")
Hier der code aus C++:


Code: Alles auswählen

 for(int i = bars- LatestBarBack -1 ; i> LatestBarForward ;i--)  //LatestBarForward - DeadlineBars weil wir diesmal um {DeadlineBars} Bars in die zukunft gehen
                     {                                     
                     static bool Long_sl,Short_sl =false;
                     for(int j=DeadlineBars; j>0;j--)
                           {
                           ResetLastError(); int error = 0;
                           if((Y_Close[i] - Y_Lows[i-j]) > Target_sl_Long*_Point)
                                 {Long_sl = true;}
                           if(( Y_Highs[i-j] - Y_Close[i]) > Target_sl_Short*_Point) 
                                 {Short_sl = true;}      
                                 
                           if( ( Y_Highs[i-j] - Y_Close[i]) >Target_tp_Long*_Point && !Long_sl ) 	
                                 {Y[i]=1;
                           else if ( (Y_Close[i] - Y_Lows[i-j] ) >Target_tp_Short*_Point && !Short_sl) 	
                                 {Y[i]=0;	
                           else if (j == DeadlineBars -1) 
                                 {Y[i]=0; 	 // bei letztem J wird Y = 0 wenn kein target       
                           }
                     }
Nach oben
Sirius3
User
Beiträge: 18270
Registriert: Sonntag 21. Oktober 2012, 17:20

Der Code ist wegen der viele überflüssigen Klammern und prints schwer lesbar.
Y["target"] sollte doch nur die Werte 0, -1 oder 1 enthalten, warum initialisierst Du ihn mit df["Close"]?
Die if-Abfrage am Ende ist übrigens kaputt, (0 or 1 or -1) ist ein logischer Ausdruck, der zu 1 evaluiert wird. Die Abfrage kann weg, da sie nie eintritt.

Das ganz mal aufgeräumt:

Code: Alles auswählen

df = pd.read_csv("Training Data/EURUSD1999-2019.csv", delimiter=",")
Y = pd.DataFrame()
Y["target"] = [0] * len(df)
for i in range(len(df)-FUTURE_PERIOD_PREDICT):
    Long_sl = False
    Short_sl = False
    close = df["Close"].iloc[i]
    for j in range(1,FUTURE_PERIOD_PREDICT):
        # gewünschter Stoploss long: wenn wert diesen wert unterschreitet, kann man die Kauf-position vergessen    
        if close - df["Low"].iloc[i+j] > Target_sl_Long:
            Long_sl = True
        # gewünschter Stoploss Short: wenn wert diesen wert unterschreitet, kann man die Leerverkauf-position vergessen 
        if df["High"].iloc[i+j] - close > Target_sl_Short:
            Short_sl = True
                
        # wenn wert innerhalb der nächsten FUTURE_PERIOD_PREDICT den gewünschten Long TakeProfit übersteigt ist es einen Kauf wert :)
        if df["High"].iloc[i+j] - close > Target_tp_Long and not Long_sl:
            Y["target"].iloc[i] = 1
            break
        # wenn wert innerhalb der nächsten FUTURE_PERIOD_PREDICT den gewünschten Short TakeProfit durchfällt ist es einen LeerVerkauf wert :)    
        elif close - df["Low"].iloc[i+j] > Target_tp_Short and not Short_sl:
            Y["target"].iloc[i] = -1
            break
    else:
        Y["target"].iloc[i] = 0
Der C-Code ist kaputt, kann also schlecht als Vorlage dienen.
Nach oben
Antworten

Zurück zu „Allgemeine Fragen“