Jump to content
Tom Next - Daytrading Community

Maschinelles Lernen mit Python - Part 1


cxalgo

Recommended Posts

Hallo Zusammen,

 

nach 2 Monaten habe ich frustriert aufgegeben, mit MQL5 und Ctrader eine saubere Lösung zu programmieren, weil einfach die Anbindung für GPU-Power, genügend freie AI, etc. Bibliotheken fehlen.

 

Fazit: nach einiger Recherche lerne ich eine neue Programmiersprache und baue hier auf die freien Bibliotheken auf. Da ich wirklich von 0 anfange, muss ich natürlich erstmal Finanzdaten visualisieren. Ich habe mich entschlossen, erstmal mit Aktien EOD (Yahoo Finance Histories) anzufangen und will den Fortschritt hier mit euch teilen, soweit Interesse besteht.

 

Ziel ist es, Lifedaten von MT4 & 5, cTrader und L&P Daten live in eine Mongo-DB zu laden, die Daten automatisch aufzubereiten, zu slicen und anschließend zu plotten (Charts).

Danach werden die Bibliotheken von R, Python, Anaconda und Mathlab angezapft und via Matrix-KPI-Metering und anderen mathematischen & statistischen Verfahren gewertet und der Computer soll mit GPU-Power möglichst präzise Vorhersagen (Predictions) errechnen können.

 

Hier die ersten Codesnippets zum visualisieren von EOD-CSV-Daten.

 

# -*- coding: utf-8 -*-
"""
Created on Tue Jan 17 09:30:18 2017

@author: MarcusLencyzk
"""

"""Slice and plot"""

import os
import pandas as pd
import matplotlib.pyplot as plt


def plot_selected(df, columns, start_index, end_index):
    """Plot the desired columns over index values in the given range."""
    plot_data(df.ix[start_index:end_index, columns], title="Selected Data")


def symbol_to_path(symbol, base_dir="data"):
    """Return CSV file path given ticker symbol."""
    return os.path.join(base_dir, "{}.csv".format(str(symbol)))


def get_data(symbols, dates):
    """Read stock data (adjusted close) for given symbols from CSV files."""
    df = pd.DataFrame(index=dates)
    if 'SPY' not in symbols:  # add SPY for reference, if absent
        symbols.insert(0, 'SPY')

    for symbol in symbols:
        df_temp = pd.read_csv(symbol_to_path(symbol), index_col='Date',
                parse_dates=True, usecols=['Date', 'Adj Close'], na_values=['nan'])
        df_temp = df_temp.rename(columns={'Adj Close': symbol})
        df = df.join(df_temp)
        if symbol == 'SPY':  # drop dates SPY did not trade
            df = df.dropna(subset=["SPY"])

    return df
    
def normalize_data(df):
    """Nomalize stock prices using the first row of the dataframe."""
    return df/ df.ix[0,:]

def plot_data(df, title="Stock prices"):
    """Plot stock prices with a custom title and meaningful axis labels."""
    ax = df.plot(title=title, fontsize=12)
    ax.set_xlabel("Date")
    ax.set_ylabel("Price")
    plt.show()


def test_run():
    # Define a date range
    dates = pd.date_range('2012-01-01', '2016-12-31')

    # Choose stock symbols to read
    symbols = ['MSFT', 'IBM', 'TXN']  # SPY will be added in get_data()
    
    # Get stock data
    df = get_data(symbols, dates)

    # Slice and plot
    plot_selected(df, ['SPY', 'IBM', 'MSFT', 'TN'], '2012-03-01', '2016-04-01')



if __name__ == "__main__":
    test_run()

 

Sieht noch sehr "simple" aus, funktioniert aber schon mal, siehe hier das Ergebnis:

 

Python_Part1.PNG

  • Upvote 7
Link to comment
Share on other sites

heute noch etwas Zeit gehabt um das Beispiel mal mit den Bollinger Band(20) zu coden und gleichzeitig zu zeigen, wie genial einfach es mit der Python Bibliothek pandas und matplotlib zu programmieren ist.

 

# -*- coding: utf-8 -*-
"""
Created on Tue Jan 17 11:11:22 2017

@author: MarcusLencyzk
"""

"""Bollinger Bands."""

import os
import pandas as pd
import matplotlib.pyplot as plt

def symbol_to_path(symbol, base_dir="data"):
    """Return CSV file path given ticker symbol."""
    return os.path.join(base_dir, "{}.csv".format(str(symbol)))


def get_data(symbols, dates):
    """Read stock data (adjusted close) for given symbols from CSV files."""
    df = pd.DataFrame(index=dates)
    if 'SPY' not in symbols:  # add SPY for reference, if absent
        symbols.insert(0, 'SPY')

    for symbol in symbols:
        df_temp = pd.read_csv(symbol_to_path(symbol), index_col='Date',
                parse_dates=True, usecols=['Date', 'Adj Close'], na_values=['nan'])
        df_temp = df_temp.rename(columns={'Adj Close': symbol})
        df = df.join(df_temp)
        if symbol == 'SPY':  # drop dates SPY did not trade
            df = df.dropna(subset=["SPY"])

    return df


def plot_data(df, title="Stock prices"):
    """Plot stock prices with a custom title and meaningful axis labels."""
    ax = df.plot(title=title, fontsize=12)
    ax.set_xlabel("Date")
    ax.set_ylabel("Price")
    plt.show()


def get_rolling_mean(values, window):
    """Return rolling mean of given values, using specified window size."""
    return pd.rolling_mean(values, window=window)


def get_rolling_std(values, window):
    """Return rolling standard deviation of given values, using specified window size."""
    return pd.rolling_std(values, window=window)
    

def get_bollinger_bands(rm, rstd):
    """Return upper and lower Bollinger Bands."""
    upper_band = rm + rstd *2
    lower_band = rm - rstd *2
    return upper_band, lower_band


def test_run():
    # Read data
    dates = pd.date_range('2012-01-01', '2012-12-31')
    symbols = ['SPY']
    df = get_data(symbols, dates)

    # Compute Bollinger Bands
    # 1. Compute rolling mean
    rm_SPY = get_rolling_mean(df['SPY'], window=20)

    # 2. Compute rolling standard deviation
    rstd_SPY = get_rolling_std(df['SPY'], window=20)

    # 3. Compute upper and lower bands
    upper_band, lower_band = get_bollinger_bands(rm_SPY, rstd_SPY)
    
    # Plot raw SPY values, rolling mean and Bollinger Bands
    ax = df['SPY'].plot(title="Bollinger Bands", label='SPY')
    rm_SPY.plot(label='Rolling mean', ax=ax)
    upper_band.plot(label='upper band', ax=ax)
    lower_band.plot(label='lower band', ax=ax)

    # Add axis labels and legend
    ax.set_xlabel("Date")
    ax.set_ylabel("Price")
    ax.legend(loc='upper left')
    plt.show()


if __name__ == "__main__":
    test_run()

 

hier das visuelle Ergebnis in Steps:

 

 

BollingerBands_long_short.PNG

BollingerBands_long_short_visual.PNG

  • Upvote 6
Link to comment
Share on other sites

Hier noch etwas für die Statistiker: Daily Returns in %

 

# -*- coding: utf-8 -*-
"""
Created on Tue Jan 17 11:25:12 2017

@author: MarcusLencyzk
"""

"""Compute daily returns."""

import os
import pandas as pd
import matplotlib.pyplot as plt

def symbol_to_path(symbol, base_dir="data"):
    """Return CSV file path given ticker symbol."""
    return os.path.join(base_dir, "{}.csv".format(str(symbol)))


def get_data(symbols, dates):
    """Read stock data (adjusted close) for given symbols from CSV files."""
    df = pd.DataFrame(index=dates)
    if 'SPY' not in symbols:  # add SPY for reference, if absent
        symbols.insert(0, 'SPY')

    for symbol in symbols:
        df_temp = pd.read_csv(symbol_to_path(symbol), index_col='Date',
                parse_dates=True, usecols=['Date', 'Adj Close'], na_values=['nan'])
        df_temp = df_temp.rename(columns={'Adj Close': symbol})
        df = df.join(df_temp)
        if symbol == 'SPY':  # drop dates SPY did not trade
            df = df.dropna(subset=["SPY"])

    return df


def plot_data(df, title="Stock prices", xlabel="Date", ylabel="Price"):
    """Plot stock prices with a custom title and meaningful axis labels."""
    ax = df.plot(title=title, fontsize=12)
    ax.set_xlabel(xlabel)
    ax.set_ylabel(ylabel)
    plt.show()


def compute_daily_returns(df):
    """Compute and return the daily return values."""
    daily_returns = df.copy() #copy given DateFrame to match size an dcolumn names
    #compute daily return for row 1 onwords
    daily_returns[1:] = (df[1:]/df[:-1].values)-1
    daily_returns.ix[0,:] = 0 #set daily return for row 0 to 0
    return daily_returns
        
    

def test_run():
    # Read data
    dates = pd.date_range('2012-07-01', '2012-07-31')  # one month only
    symbols = ['SPY','TXN']
    df = get_data(symbols, dates)
    plot_data(df)

    # Compute daily returns
    daily_returns = compute_daily_returns(df)
    plot_data(daily_returns, title="Daily returns", ylabel="Daily returns")


if __name__ == "__main__":
    test_run()

 

Daily_returns.PNG

Daily_returns_visual.PNG

  • Upvote 4
Link to comment
Share on other sites

Viel Erfolg bei Deinem Projekt. An einem Konverter von Kursdaten aus MT4 (MT5) währe ich auch schwer interessiert. Bin mir aber nicht sicher, ob ich das brauche. Scheint Lösungen für Amibroker zu geben.

 

Aber egal: Warum nicht ein Script schreiben, dass in regelmässigen Abständen durch die MT4-Kursliste geht, einem Moment wg. Kursdatenaktualisierung wartet und dann diese Daten an einem Speicherort der Wahl abspeichert.

 

Zwei Fragen habe ich noch, warum MongoDB und nicht MySQL oder SqLite? Warum die """ im Quellcode? Wg. einer späteren maschinellen Erstellung der Dokumentation des Programms? Fast ein paar

  • Upvote 1
Link to comment
Share on other sites

Danke sehr. Konverter steht auf alle Fälle auf meiner Liste und gebe hier gerne bescheid.

 

MongoDB wegen NoSql und ArrayDB-Funktionalität bzw. In-Memory. Ich will ja nicht immer die Kursdaten als Primary-Key nehmen, sondern Titel zu bestimmte Szenarien indexieren lassen und passende HS via AI finden, bzw. Ableitungen von HS, so die Idee dahinter.

 

Die """ stehen für Parser-Entries, damit sich das System selbst dokumentiert und hier neue Ableitungen eintragen kann, quasi als Text-Trigger

  • Upvote 4
Link to comment
Share on other sites

  • 3 years later...

MongoDB wegen NoSql und ArrayDB-Funktionalität bzw. In-Memory. Ich will ja nicht immer die Kursdaten als Primary-Key nehmen, sondern Titel zu bestimmte Szenarien indexieren lassen und passende HS via AI finden, bzw. Ableitungen von HS, so die Idee dahinter.

 

Ist von der Infratruktur her langfristig alles gut gelaufen?

Ich stelle gerade meine kompletten Datenspeicherung/bereithaltung um und bin die Themen Flat File vs DBMS soweit mal durchgegegangen und zum Zwischenstand gekommen, dass wenn eine DBMS, dann eher eine time series database (TSDB) welche nochmal klare Performancevorteile gegenüber DB wie MongoDB haben sollte.

Beim schreiben ist wohl egal weils nur intervallweise reinkommt aber hat MongoDB ausgereicht fürs Lesen?, stelle mir das langsam vor wenn viele Daten oft geholt werden von vielen Workern welche die Hist zB durchiterieren...

Schwanke zwischen Flat File und einer TSDB. Aber auch MongoDB, nur hab ich noch keine so besonderen Argumente für den usecase Trading gefunden daher mein Interesse wie die Erfahrung damit ist/war?

Grüße

Link to comment
Share on other sites

Sowas wie Shelve klingt sehr praktisch, bin allerdings in Cpp unterwegs da ist manches etwas umständlicher dafür aber performanter. Der TO rechnet aber interessanterweise auf GPU daher ist die Sprache dann fast egal da hat man noch ganz andere Probleme zu lösen. MongoDB hat einen sehr guten Ruf daher hatte mich das mal interessiert inwiefern sich MongoDB mit dem usecase Trading verträgt. Funktionieren tut es damit natürlich aber es ist nicht direkt auf Zeitreihen optimiert wie eine TSDB. Kleiner Erfahrungsbericht MongoDB in dem Zusammenhang wäre daher spannend, die Frage ist nur ob @cxalgo überhaupt noch hier unterwegs ist, wie schon festgestellt ist generell weniger los überall zum Thema wink.gif Flat File ist für reine sequenzielle auslesen wahrscheinlich am schnellsten allerdings muss man da eben parallele Zugriffe dann selbst synchronisieren was auch nicht ganz ohne ist.

Link to comment
Share on other sites

Bin hier leider auch raus. Bei mir spielt Perfomance keine Rolle. Mir ist eher wichtig, schnell ein UseCase erstellen zu können. Quick&Dirty, Rest ist mir egal.... :)

Wenn es um Performance geht, dann doch mal die ganzen BigData-Tools mal heranziehen. Was für was gut ist, würde mich auch mal interessieren:
https://towardsdatascience.com/what-is-tensorframes-tensorflow-apache-spark-a385ec4bc1d5

Für komplexe und rechenintensive Anwendungen gibs damit auf jedenfall Lösungsansätze: Multicoreberchnungen, aufstocken mittels CloudCluster, Berechnungen auf GPUs.

Link to comment
Share on other sites

InfluxDB kann ich dir dafür empfehlen. Ich würde das Rad nicht neu erfinden.

 

Die Roh-Daten kannst du dann mit Telegraf einfach einlesen und in die Datenbank schreiben. Einfach einen Input zB. nen Script und dazu einen Output auf die InfluxDB konfigurieren.

Dafür brauchst du dann das InfluxDB Line Protocol.

 

Die Datenbank selbst hat eben den Vorteil das du Queries absetzen kannst, die speziell für Zeitreihen gemacht sind.

Dieses Featureset bekommst du nicht selber gebaut in absehbarer Zeit.

 

 

Auch Dashboards bekommst du über Chronograf oder Grafana.

 

InfluxDB 2.0 ist recht frisch rausgekommen. Ich denke das Thema ist größer und dauert etwas länger für die Einarbeitung.

Aber am Ende hast du dann eben doch eine performante Lösung auf der man langfristig aufbauen kann.

  • Upvote 1
Link to comment
Share on other sites

Aber am Ende hast du dann eben doch eine performante Lösung auf der man langfristig aufbauen kann.

 

Nochmal eine Frage an die Datenbankuser, wendet ihr die DB auch direkt für den Livebetrieb an oder nur zur Bereitstellung für Strategieentwicklung oder beides?

 

Bei Livebetrieb gibt es verschiedene Varianten wie die hereinkommenden Ticks das Handelssystem triggern. Handelsysteme sind event-driven insofern gäbe es drei theoretische Möglichkeiten im Livebetrieb mal ganz unabhängig woher die Datenquelle kommt.

 

V1. Ein Empfängerprogramm bekommt neue Ticks (von beliebiger Quelle) und gibt sie weiter an:

- zur Ausführung an ein Handelssystem

- zur Speicherung an die Datenbank

 

V2. Die Datenbank selbst bekommt alle neuen Ticks (von beliebiger Quelle) und speichert sie und müsste dann irgendwie die Handelssysteme triggern damit sie wiederum zur Ausführung den neuen Tick aus der DB holen.

Ob DB überhaupt Programme/Threads triggern können weiß ich nicht mal?, bzw stelle ich mir die Zuordnung schwer vor, denn jedes Handelssystem kann Daten von einem bestimmten Asset wollen, die DB müsste wissen welches Programm welche Daten will und dieses bei Daten-Aktualisierung triggern.

 

V3. Datenbank und Livebetrieb sind zwei unterschiedliche Kreisläufe.

Datenbank wird in bestimmten Zeitabstand zB jede Stunde aktualisiert mit den historischen Daten bis zum aktuellen Zeitpunkt.

getrennt davon:

Handelssysteme bekommen event-driven die nötigen LiveTicks.

 

Der TO schreibt hier von livedaten aber optimiert wird sicherlich immer ein fixer Zeitbereich. Insofern wäre interessant ob der Livebetrieb überhaupt was mit der DB zu tun haben sollte und Entwicklung/Optimierung mit DB ein seperater Kreislauf ist?

Man könnte die Speicherung in der DB auch komplett abkoppeln vom Livebetrieb wie V3.

 

Wie macht ihr das bzw habt ihr mit der ein oder anderen Vorgehensweise gute Erfahrungen gemacht?

Ich tendiere zu V3 ggf V1

Edited by Forex1+
Link to comment
Share on other sites

Wenn es um Geschwindigkeit geht, dann vielleicht auch Programmiersprache Julia anschauen. Mit der kann man auch in Anaconda > Jupyter rumspielen....

 


„Julia ist bei einfachen Machine-Learning-Aufgaben mit Python vergleichbar, aber besser geeignet für komplexere.“
https://entwickler.de/online/machine-learning/julia-programmiersprache-interview-579933983.html


Programmiersprachen-Benchmark: Julia liest Daten viel schneller als Python und R
https://www.heise.de/news/Programmiersprachen-Benchmark-Julia-liest-Daten-viel-schneller-als-Python-und-R-4793906.html


Link to comment
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Reply to this topic...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

Loading...
×
×
  • Create New...