Ein datengesteuerter Ansatz zur Analyse digitaler Währungsspekulationen

Wie entwickelt sich der Bitcoin Kurs? Was führt zu rasanten Kursanstiegen und Kursverfällen bei Kryptowährungen? Sind die Marktpreise verschiedener Altcoins untrennbar miteinander verbunden oder sind sie weitgehend unabhängig? Wie können wir vorhersagen, was als nächstes passieren wird?

In Artikeln über digitale Währungen wie Bitcoin und Ethereum wimmelt es mittlerweile von Spekulationen. Hunderte selbsternannte Experten befürworten Trends, die ihrer Meinung nach aufkommen werden. Was vielen dieser Analysen fehlt, ist eine solide Grundlage an zugrunde liegenden Daten und statistischen Modellen.

Das Ziel dieses Artikels ist es, eine einfache Einführung in die Kryptowährungsanalyse mit Python zu geben. Wir werden ein einfaches Python-Skript durchgehen, um Daten für verschiedene Kryptowährungen abzurufen, zu analysieren und zu visualisieren. Dabei werden wir interessante Trends im Verhalten und der Entwicklung dieser volatilen Märkte entdecken.

Dies ist kein Artikel, der Kryptowährungen erklärt, und auch kein Meinungsbeitrag zu der Frage, welche bestimmten Währungen steigen und welche fallen werden. Stattdessen konzentrieren wir uns in diesem Tutorial einfach darauf, die Rohdaten zu nehmen und die in den Zahlen verborgenen Geschichten zu entdecken.

Schritt 1: Erstellen Sie unsere Datenarbeitsumgebung

Dieses Tutorial richtet sich an Enthusiasten, Ingenieure und Datenwissenschaftler aller Fähigkeitsstufen. Egal, ob Sie ein Branchenexperte oder ein Programmieranfänger sind, Sie benötigen lediglich grundlegende Kenntnisse der Programmiersprache Python und ausreichende Kenntnisse der Befehlszeilenoperationen. (Sie müssen lediglich in der Lage sein, ein Data-Science-Projekt einzurichten).

1.1 Inventor Quant Host installieren und Anaconda einrichten

• Erfinder des Quantified Custodian Systems

Zusätzlich zur Bereitstellung hochwertiger Datenquellen von den wichtigsten Mainstream-Börsen bietet die Inventor Quantitative Platform FMZ.COM auch eine Vielzahl von API-Schnittstellen, die uns dabei helfen, nach Abschluss der Datenanalyse automatisierte Transaktionen durchzuführen. Dieser Satz von Schnittstellen umfasst praktische Tools wie die Abfrage von Kontoinformationen, die Abfrage von Höchst-, Eröffnungs-, Tiefst- und Schlusskursen, Handelsvolumen, verschiedenen häufig verwendeten technischen Analyseindikatoren verschiedener Mainstream-Börsen usw., insbesondere für die Verbindung mit den wichtigsten Mainstream-Börsen in der Praxis Handelsprozesse. Die öffentliche API-Schnittstelle bietet leistungsstarken technischen Support.

Alle oben genannten Funktionen sind in einem Docker-ähnlichen System gekapselt. Wir müssen lediglich unseren eigenen Cloud-Computing-Dienst kaufen oder mieten und dann das Docker-System bereitstellen.

Im offiziellen Namen der Inventor Quantitative Platform wird dieses Docker-System als Hostsystem bezeichnet.

Weitere Informationen zum Bereitstellen von Hosts und Robotern finden Sie in meinem vorherigen Artikel: https://www.fmz.com/bbs-topic/4140

Leser, die ihren eigenen Cloud-Computing-Server-Bereitstellungshost erwerben möchten, können diesen Artikel lesen: https://www.fmz.com/bbs-topic/2848

Nach der erfolgreichen Bereitstellung des Cloud-Computing-Dienstes und des Hostsystems installieren wir das leistungsstärkste Python-Tool: Anaconda

Um alle für diesen Artikel relevanten Programmumgebungen (abhängige Bibliotheken, Versionsverwaltung etc.) zu realisieren, bietet sich am einfachsten die Verwendung von Anaconda an. Es handelt sich um ein gepacktes Python-Data-Science-Ökosystem und einen Abhängigkeitsmanager.

Da wir Anaconda auf einem Cloud-Dienst installieren, empfehlen wir Ihnen, das Linux-System und die Befehlszeilenversion von Anaconda auf dem Cloud-Server zu installieren.

Informationen zur Installationsmethode von Anaconda finden Sie im offiziellen Handbuch von Anaconda: https://www.anaconda.com/distribution/

Wenn Sie ein erfahrener Python-Programmierer sind und nicht das Bedürfnis haben, Anaconda zu verwenden, ist das völlig in Ordnung. Ich gehe davon aus, dass Sie bei der Installation der erforderlichen Abhängigkeiten keine Hilfe benötigen und direkt zu Teil 2 springen können.

1.2 Erstellen Sie eine Anaconda-Datenanalyseprojektumgebung

Nachdem Anaconda installiert ist, müssen wir eine neue Umgebung erstellen, um unsere Abhängigkeitspakete zu verwalten. In der Linux-Kommandozeilenschnittstelle geben wir ein:

conda create --name cryptocurrency-analysis python=3

Erstellen wir eine neue Anaconda-Umgebung für unser Projekt.

Geben Sie als nächstes ein

source activate cryptocurrency-analysis (linux/MacOS操作)
或者
activate cryptocurrency-analysis (windows操作系统)

So aktivieren Sie diese Umgebung

Geben Sie als Nächstes Folgendes ein:

conda install numpy pandas nb_conda jupyter plotly

Um die verschiedenen Abhängigkeitspakete zu installieren, die für dieses Projekt erforderlich sind.

Hinweis: Warum eine Anaconda-Umgebung verwenden? Wenn Sie vorhaben, viele Python-Projekte auf Ihrem Computer auszuführen, ist es hilfreich, die Abhängigkeiten (Bibliotheken und Pakete) verschiedener Projekte zu trennen, um Konflikte zu vermeiden. Ananconda erstellt für das Abhängigkeitspaket jedes Projekts ein spezielles Umgebungsverzeichnis, sodass alle Pakete ordnungsgemäß verwaltet und unterschieden werden können.

1.3 Erstellen Sie ein Jupyter-Notebook

Nachdem die Umgebung und die Abhängigkeitspakete installiert wurden, führen Sie aus

jupyter notebook

um den iPython-Kernel zu starten, richten Sie Ihren Browser dann auf http://localhost:8888/ und erstellen Sie ein neues Python-Notebook. Stellen Sie sicher, dass es Folgendes verwendet:

Python [conda env:cryptocurrency-analysis]

Kernel

1.4 Abhängige Pakete importieren

Erstellen Sie ein neues leeres Jupyter-Notebook. Als Erstes müssen wir die erforderlichen Abhängigkeitspakete importieren.

import os
import numpy as np
import pandas as pd
import pickle
from datetime import datetime

Wir müssen auch Plotly importieren und den Offline-Modus aktivieren

import plotly.offline as py
import plotly.graph_objs as go
import plotly.figure_factory as ff
py.init_notebook_mode(connected=True)

Schritt 2: Preisinformationen zur digitalen Währung erhalten

Nachdem die Vorbereitungen abgeschlossen sind, können wir mit der Erfassung der zu analysierenden Daten beginnen. Zuerst müssen wir die API-Schnittstelle der Inventor Quantitative Platform verwenden, um Bitcoin-Preisdaten zu erhalten.

Dabei wird die Funktion GetTicker verwendet. Einzelheiten zur Verwendung dieser beiden Funktionen finden Sie unter: https://www.fmz.com/api

2.1 Schreiben Sie die Quandl-Datenerfassungsfunktion

Um die Datenerfassung zu erleichtern, müssen wir eine Funktion zum Herunterladen und Synchronisieren von Daten von Quandl (quandl.com) schreiben. Dabei handelt es sich um eine kostenlose Finanzdatenschnittstelle, die im Ausland große Bekanntheit genießt. Auch die Inventor Quantitative Platform bietet eine ähnliche Datenschnittstelle, die vor allem für den Echtzeithandel genutzt wird. Da es in diesem Artikel vor allem um die Datenanalyse geht, verwenden wir hier dennoch Quandls Daten.

Beim Handel in Echtzeit können Sie die Funktionen GetTicker und GetRecords direkt in Python aufrufen, um Preisdaten abzurufen. Informationen zu ihrer Verwendung finden Sie unter: https://www.fmz.com/api

def get_quandl_data(quandl_id):
    # 下载和缓冲来自Quandl的数据列
    cache_path = '{}.pkl'.format(quandl_id).replace('/','-')
    try:
        f = open(cache_path, 'rb')
        df = pickle.load(f)   
        print('Loaded {} from cache'.format(quandl_id))
    except (OSError, IOError) as e:
        print('Downloading {} from Quandl'.format(quandl_id))
        df = quandl.get(quandl_id, returns="pandas")
        df.to_pickle(cache_path)
        print('Cached {} at {}'.format(quandl_id, cache_path))
    return df

Die Pickle-Bibliothek wird hier verwendet, um die Daten zu serialisieren und die heruntergeladenen Daten als Datei zu speichern, sodass das Programm nicht bei jedem Ausführen dieselben Daten erneut herunterlädt. Diese Funktion gibt die Daten im Pandas-Dataframe-Format zurück. Wenn Sie mit dem Konzept eines Datenrahmens nicht vertraut sind, stellen Sie es sich als eine leistungsstarke Excel-Tabelle vor.

2.2 Abrufen von Kryptowährungspreisdaten von Kraken Exchange

Nehmen wir als Beispiel die Bitcoin-Börse Kraken und ermitteln zunächst den Bitcoin-Preis.

# 获取Kraken比特币交易所的价格
btc_usd_price_kraken = get_quandl_data('BCHARTS/KRAKENUSD')

Verwenden Sie die Methode head(), um die ersten fünf Zeilen des Datenrahmens anzuzeigen.

btc_usd_price_kraken.head()

Das Ergebnis ist:

BTC	Open	High	Low	Close	Volume (BTC)	Volume (Currency)	Weighted Price
2014-01-07	874.67040	892.06753	810.00000	810.00000	15.622378	13151.472844	841.835522
2014-01-08	810.00000	899.84281	788.00000	824.98287	19.182756	16097.329584	839.156269
2014-01-09	825.56345	870.00000	807.42084	841.86934	8.158335	6784.249982	831.572913
2014-01-10	839.99000	857.34056	817.00000	857.33056	8.024510	6780.220188	844.938794
2014-01-11	858.20000	918.05471	857.16554	899.84105	18.748285	16698.566929	890.671709

Als nächstes müssen wir eine einfache Tabelle erstellen, um die Richtigkeit der Daten durch Visualisierung zu überprüfen.

# 做出BTC价格的表格
btc_trace = go.Scatter(x=btc_usd_price_kraken.index, y=btc_usd_price_kraken['Weighted Price'])
py.iplot([btc_trace])

Hier verwenden wir Plotly, um den Visualisierungsteil abzuschließen. Plotly ist eine weniger gebräuchliche Wahl als die Verwendung einiger der ausgereifteren Python-Datenvisualisierungsbibliotheken wie Matplotlib, aber es ist eine gute Wahl, da es D3.js für vollständig interaktive Diagramme aufrufen kann. Die Diagramme haben sehr schöne Standardeinstellungen, sind leicht zu erkunden und lassen sich sehr bequem in Webseiten einbetten.

Tipp: Sie können das generierte Diagramm mit einem Bitcoin-Preisdiagramm einer großen Börse (wie dem von OKEX, Binance oder Huobi) vergleichen, um eine schnelle Plausibilitätsprüfung durchzuführen und sicherzustellen, dass die heruntergeladenen Daten ungefähr übereinstimmen.

2.3 Preisdaten von großen Bitcoin-Börsen beziehen

Aufmerksamen Lesern ist möglicherweise aufgefallen, dass in den obigen Daten Daten fehlen, insbesondere für Ende 2014 und Anfang 2016. Besonders deutlich ist diese Datenlücke bei der Kraken-Börse. Wir möchten auf keinen Fall, dass diese fehlenden Daten unsere Preisanalyse beeinflussen.

Die Besonderheit digitaler Währungsbörsen besteht darin, dass der Preis der Währung durch Angebot und Nachfrage bestimmt wird. Daher kann kein Transaktionspreis zum „Mainstream-Preis“ des Marktes werden. Um dieses Problem sowie das gerade erwähnte Problem fehlender Daten (möglicherweise aufgrund technischer Ausfälle und Datenfehler) zu beheben, werden wir Daten von den drei größten Bitcoin-Börsen der Welt herunterladen und den durchschnittlichen Bitcoin-Preis berechnen.

Beginnen wir mit dem Herunterladen der Daten für jeden Austausch in einen Datenrahmen, der aus einem Wörterbuchtyp besteht.

# 下载COINBASE，BITSTAMP和ITBIT的价格数据
exchanges = ['COINBASE','BITSTAMP','ITBIT']

exchange_data = {}

exchange_data['KRAKEN'] = btc_usd_price_kraken

for exchange in exchanges:
    exchange_code = 'BCHARTS/{}USD'.format(exchange)
    btc_exchange_df = get_quandl_data(exchange_code)
    exchange_data[exchange] = btc_exchange_df

2.4 Alle Daten in einen Datenrahmen integrieren

Als Nächstes definieren wir eine spezielle Funktion, um die gemeinsamen Spalten aus jedem Datenrahmen in einem neuen Datenrahmen zusammenzuführen. Nennen wir es merge_dfs_on_column Funktion

def merge_dfs_on_column(dataframes, labels, col):
    '''Merge a single column of each dataframe into a new combined dataframe'''
    series_dict = {}
    for index in range(len(dataframes)):
        series_dict[labels[index]] = dataframes[index][col]
        
    return pd.DataFrame(series_dict)

Kombinieren Sie nun alle Datenrahmen basierend auf der Spalte „gewichteter Preis“ jedes Datensatzes.

# 整合所有数据帧
btc_usd_datasets = merge_dfs_on_column(list(exchange_data.values()), list(exchange_data.keys()), 'Weighted Price')

Abschließend verwenden wir die Methode „tail()“, um die letzten fünf Zeilen der zusammengeführte Daten anzuzeigen und sicherzustellen, dass die Daten korrekt und vollständig sind.

btc_usd_datasets.tail()

Das Ergebnis ist:

BTC	BITSTAMP	COINBASE	ITBIT	KRAKEN
2017-08-14	4210.154943	4213.332106	4207.366696	4213.257519
2017-08-15	4101.447155	4131.606897	4127.036871	4149.146996
2017-08-16	4193.426713	4193.469553	4190.104520	4187.399662
2017-08-17	4338.694675	4334.115210	4334.449440	4346.508031
2017-08-18	4182.166174	4169.555948	4175.440768	4198.277722

Wie aus der obigen Tabelle ersichtlich ist, entsprechen diese Daten unseren Erwartungen und der Datenbereich ist ungefähr gleich, es gibt jedoch geringfügige Unterschiede, die auf der Latenz oder den Eigenschaften der einzelnen Börsen basieren.

2.5 Preisdatenvisualisierungsprozess

Aus der Perspektive der analytischen Logik besteht der nächste Schritt darin, diese Daten durch Visualisierung zu vergleichen. Dazu müssen wir zunächst eine Hilfsfunktion definieren, die die Daten verwendet, um mithilfe eines einzeiligen Befehls ein Diagramm zu erstellen. Nennen wir sie die Funktion df_scatter.

def df_scatter(df, title, seperate_y_axis=False, y_axis_label='', scale='linear', initial_hide=False):
    '''Generate a scatter plot of the entire dataframe'''
    label_arr = list(df)
    series_arr = list(map(lambda col: df[col], label_arr))
    
    layout = go.Layout(
        title=title,
        legend=dict(orientation="h"),
        xaxis=dict(type='date'),
        yaxis=dict(
            title=y_axis_label,
            showticklabels= not seperate_y_axis,
            type=scale
        )
    )
    
    y_axis_config = dict(
        overlaying='y',
        showticklabels=False,
        type=scale )
    
    visibility = 'visible'
    if initial_hide:
        visibility = 'legendonly'
        
    # 每个系列的表格跟踪
    trace_arr = []
    for index, series in enumerate(series_arr):
        trace = go.Scatter(
            x=series.index, 
            y=series, 
            name=label_arr[index],
            visible=visibility
        )
        
        # 为系列添加单独的轴
        if seperate_y_axis:
            trace['yaxis'] = 'y{}'.format(index + 1)
            layout['yaxis{}'.format(index + 1)] = y_axis_config    
        trace_arr.append(trace)

    fig = go.Figure(data=trace_arr, layout=layout)
    py.iplot(fig)

Damit Sie es leichter verstehen, wird in diesem Artikel nicht näher auf das logische Prinzip dieser Hilfsfunktion eingegangen. Wenn Sie mehr erfahren möchten, sehen Sie sich die offizielle Dokumentation für Pandas und Plotly an.

Jetzt können wir ganz einfach Diagramme mit Bitcoin-Preisdaten erstellen!

# 绘制所有BTC交易价格
df_scatter(btc_usd_datasets, 'Bitcoin Price (USD) By Exchange')

2.6 Saubere und aggregierte Preisdaten

Wie Sie der obigen Grafik entnehmen können, weisen die vier Reihen zwar ungefähr den gleichen Verlauf auf, es gibt jedoch einige Unregelmäßigkeiten, die wir zu beheben versuchen werden.

Wir wissen, dass der Preis von Bitcoin im Zeitraum von 2012 bis 2017 nie gleich Null war, daher entfernen wir zunächst alle Nullwerte im Datenrahmen.

# 清除"0"值
btc_usd_datasets.replace(0, np.nan, inplace=True)

Nach dem Neuaufbau des Datenrahmens können wir ein viel klareres Diagramm ohne fehlende Daten sehen.

# 绘制修订后的数据框
df_scatter(btc_usd_datasets, 'Bitcoin Price (USD) By Exchange')

Wir können jetzt eine neue Spalte berechnen: den durchschnittlichen Tagespreis von Bitcoin an allen Börsen.

# 将平均BTC价格计算为新列
btc_usd_datasets['avg_btc_price_usd'] = btc_usd_datasets.mean(axis=1)

Die neue Spalte ist der Bitcoin-Preisindex! Lassen Sie uns das Diagramm noch einmal erstellen, um zu prüfen, ob mit den Daten etwas nicht stimmt.

# 绘制平均BTC价格
btc_trace = go.Scatter(x=btc_usd_datasets.index, y=btc_usd_datasets['avg_btc_price_usd'])
py.iplot([btc_trace])

Es scheint, als gäbe es kein Problem, und wir werden diese aggregierten Preisreihendaten später weiterhin verwenden, um den Wechselkurs zwischen anderen Kryptowährungen und dem US-Dollar bestimmen zu können.

Schritt 3: Sammeln Sie die Preise der Altcoins

Bisher liegen uns Zeitreihendaten zum Bitcoin-Preis vor. Als nächstes schauen wir uns einige Daten zu anderen digitalen Währungen als Bitcoin an, nämlich die Situation der Altcoins. Natürlich ist der Begriff Altcoin vielleicht etwas zu stark, aber was die aktuelle Entwicklung der digitalen Währungen betrifft, so gibt es neben dem Marktkapitalisierungsranking Die meisten der Top Ten (wie Bitcoin, Ethereum, EOS, USDT usw.) können als Altcoins bezeichnet werden. Es gibt kein Problem. Wir sollten versuchen, uns beim Handel von diesen Währungen fernzuhalten, da sie zu verwirrend und irreführend sind.

3.1 Definieren von Zusatzfunktionen über die Poloniex-Börsen-API

Zunächst verwenden wir die API der Poloniex-Börse, um Dateninformationen zu digitalen Währungstransaktionen zu erhalten. Wir definieren zwei Hilfsfunktionen, um die relevanten Daten von Altcoins zu erhalten. Diese beiden Funktionen laden hauptsächlich JSON-Daten über die API herunter und zwischenspeichern sie.

Zuerst definieren wir die Funktion get_json_data, die JSON-Daten von einer bestimmten URL herunterlädt und zwischenspeichert.

def get_json_data(json_url, cache_path):
    '''Download and cache JSON data, return as a dataframe.'''
    try:        
        f = open(cache_path, 'rb')
        df = pickle.load(f)   
        print('Loaded {} from cache'.format(json_url))
    except (OSError, IOError) as e:
        print('Downloading {}'.format(json_url))
        df = pd.read_json(json_url)
        df.to_pickle(cache_path)
        print('Cached {} at {}'.format(json_url, cache_path))
    return df

Als Nächstes definieren wir eine neue Funktion, die eine HTTP-Anfrage an die Poloniex-API sendet und die gerade definierte Funktion get_json_data aufruft, um das Ergebnis des Aufrufs zu speichern.

base_polo_url = 'https://poloniex.com/public?command=returnChartData&currencyPair={}&start={}&end={}&period={}'
start_date = datetime.strptime('2015-01-01', '%Y-%m-%d') # 从2015年开始获取数据
end_date = datetime.now() # 直到今天
pediod = 86400 # pull daily data (86,400 seconds per day)

def get_crypto_data(poloniex_pair):
    '''Retrieve cryptocurrency data from poloniex'''
    json_url = base_polo_url.format(poloniex_pair, start_date.timestamp(), end_date.timestamp(), pediod)
    data_df = get_json_data(json_url, poloniex_pair)
    data_df = data_df.set_index('date')
    return data_df

Die obige Funktion extrahiert den String-Code des Kryptowährungspaares (z. B. „BTC_ETH“) und gibt einen Datenrahmen zurück, der die historischen Preise beider Währungen enthält.

3.2 Herunterladen von Transaktionspreisdaten von Poloniex

Die meisten Altcoins können nicht direkt mit US-Dollar gekauft werden. Wenn Einzelpersonen diese digitalen Währungen erwerben möchten, müssen sie normalerweise zuerst Bitcoin kaufen und sie dann basierend auf dem Preisverhältnis zwischen ihnen in Altcoins umtauschen. Daher müssen wir den Wechselkurs für jede digitale Währung in Bitcoin herunterladen und dann die vorhandenen Bitcoin-Preisdaten für die Umrechnung in US-Dollar verwenden. Wir laden Transaktionsdaten für 9 Top-Kryptowährungen herunter: Ethereum, Litecoin, Ripple, EthereumClassic, Stellar, Dash, Siacoin, Monero und NEM.

altcoins = ['ETH','LTC','XRP','ETC','STR','DASH','SC','XMR','XEM']

altcoin_data = {}
for altcoin in altcoins:
    coinpair = 'BTC_{}'.format(altcoin)
    crypto_price_df = get_crypto_data(coinpair)
    altcoin_data[altcoin] = crypto_price_df

Wir haben jetzt ein Wörterbuch mit 9 Datenrahmen, von denen jeder historische tägliche Durchschnittspreisdaten zwischen Altcoins und Bitcoin enthält.

Ob die Daten korrekt sind, können wir anhand der letzten Zeilen der Ethereum-Preistabelle feststellen.

altcoin_data['ETH'].tail()

ETH	Open	High	Low	Close	Volume (BTC)	Volume (Currency)	Weighted Price
2017-08-18	0.070510	0.071000	0.070170	0.070887	17364.271529	1224.762684	0.070533
2017-08-18	0.071595	0.072096	0.070004	0.070510	26644.018123	1893.136154	0.071053
2017-08-18	0.071321	0.072906	0.070482	0.071600	39655.127825	2841.549065	0.071657
2017-08-19	0.071447	0.071855	0.070868	0.071321	16116.922869	1150.361419	0.071376
2017-08-19	0.072323	0.072550	0.071292	0.071447	14425.571894	1039.596030	0.072066

3.3 Alle Preisangaben sollten in US-Dollar angegeben werden

Wir können jetzt die Wechselkursdaten von BTC zu Altcoins mit unserem Bitcoin-Preisindex kombinieren, um den historischen Preis jeder Altcoin direkt in USD zu berechnen.

# 将USD Price计算为每个altcoin数据帧中的新列
for altcoin in altcoin_data.keys():
    altcoin_data[altcoin]['price_usd'] =  altcoin_data[altcoin]['weightedAverage'] * btc_usd_datasets['avg_btc_price_usd']

Hier fügen wir dem Datenrahmen für jede Altcoin eine neue Spalte hinzu, um den entsprechenden USD-Preis zu speichern.

Als Nächstes können wir die zuvor definierte Funktion „merge_dfs_on_column“ wiederverwenden, um einen zusammengeführte Datenrahmen zu erstellen, der den USD-Preis jeder Kryptowährung integriert.

# 将每个山寨币的美元价格合并为单个数据帧
combined_df = merge_dfs_on_column(list(altcoin_data.values()), list(altcoin_data.keys()), 'price_usd')

Erledigt!

Fügen wir nun auch den Bitcoin-Preis als letzte Spalte zum zusammengeführte Datenrahmen hinzu.

# 将BTC价格添加到数据帧
combined_df['BTC'] = btc_usd_datasets['avg_btc_price_usd']

Jetzt haben wir einen einzigartigen Datenrahmen, der die täglichen USD-Preise für die zehn Kryptowährungen enthält, die wir validieren.

Wir rufen die vorherige Funktion df_scatter erneut auf, um die entsprechenden Preise aller Altcoins in Form eines Diagramms anzuzeigen.

Das Diagramm sieht gut aus und gibt uns ein vollständiges Bild davon, wie sich der Wechselkurs der einzelnen Kryptowährungen in den letzten Jahren verändert hat.

Hinweis: Hier haben wir eine logarithmische Y-Achse verwendet, um alle Kryptowährungen im selben Diagramm zu vergleichen. Sie können auch verschiedene Parameterwerte ausprobieren (z. B. scale = ‚linear‘), um die Daten aus verschiedenen Perspektiven zu verstehen.

3.4 Korrelationsanalyse starten

Aufmerksamen Lesern ist möglicherweise aufgefallen, dass die Preise digitaler Währungen korreliert zu sein scheinen, auch wenn ihre Geldwerte stark schwanken und einer hohen Volatilität unterliegen. Insbesondere seit dem rasanten Anstieg im April 2017 scheinen selbst viele kleine Schwankungen im Einklang mit den Schwankungen des Gesamtmarktes aufzutreten.

Natürlich sind durch Daten gestützte Schlussfolgerungen überzeugender als auf Bildern basierende Intuitionen.

Wir können die Pandas-Funktion corr() verwenden, um die obige Korrelationshypothese zu überprüfen. Dieser Test berechnet den Pearson-Korrelationskoeffizienten für jede Spalte des Datenrahmens mit jeder anderen Spalte.

22.08.2017 Revisionshinweis: Dieser Abschnitt wurde geändert, um bei der Berechnung der Korrelationskoeffizienten tägliche Renditen statt absoluter Preise zu verwenden.

Eine direkte Berechnung auf Basis nicht solider Zeitreihen (wie etwa Rohpreisdaten) kann zu Abweichungen im Korrelationskoeffizienten führen. Unsere Lösung für dieses Problem besteht darin, die Methode pct_change() zu verwenden, um den absoluten Wert jedes Preises im Datenrahmen in die entsprechende tägliche Rendite umzuwandeln.

Berechnen wir beispielsweise den Korrelationskoeffizienten für das Jahr 2016.

# 计算2016年数字货币的皮尔森相关系数
combined_df_2016 = combined_df[combined_df.index.year == 2016]
combined_df_2016.pct_change().corr(method='pearson')

Name	DASH	ETC	ETH	LTC	SC	STR	XEM	XMR	XRP	BTC
DASH	1.000000	0.003992	0.122695	-0.012194	0.026602	0.058083	0.014571	0.121537	0.088657	-0.014040
ETC	0.003992	1.000000	-0.181991	-0.131079	-0.008066	-0.102654	-0.080938	-0.105898	-0.054095	-0.170538
ETH	0.122695	-0.181991	1.000000	-0.064652	0.169642	0.035093	0.043205	0.087216	0.085630	-0.006502
LTC	-0.012194	-0.131079	-0.064652	1.000000	0.012253	0.113523	0.160667	0.129475	0.053712	0.750174
SC	0.026602	-0.008066	0.169642	0.012253	1.000000	0.143252	0.106153	0.047910	0.021098	0.035116
STR	0.058083	-0.102654	0.035093	0.113523	0.143252	1.000000	0.225132	0.027998	0.320116	0.079075
XEM	0.014571	-0.080938	0.043205	0.160667	0.106153	0.225132	1.000000	0.016438	0.101326	0.227674
XMR	0.121537	-0.105898	0.087216	0.129475	0.047910	0.027998	0.016438	1.000000	0.027649	0.127520
XRP	0.088657	-0.054095	0.085630	0.053712	0.021098	0.320116	0.101326	0.027649	1.000000	0.044161
BTC	-0.014040	-0.170538	-0.006502	0.750174	0.035116	0.079075	0.227674	0.127520	0.044161	1.000000

Die obige Grafik zeigt die Korrelationskoeffizienten. Ein Koeffizient nahe 1 oder -1 bedeutet, dass die Folge positiv bzw. invers korreliert ist. Ein Korrelationskoeffizient nahe 0 bedeutet, dass die entsprechenden Objekte nicht korreliert sind und ihre Schwankungen voneinander unabhängig sind.

Um die Ergebnisse besser zu visualisieren, erstellen wir eine neue Visualisierungshilfsfunktion.

def correlation_heatmap(df, title, absolute_bounds=True):
    '''Plot a correlation heatmap for the entire dataframe'''
    heatmap = go.Heatmap(
        z=df.corr(method='pearson').as_matrix(),
        x=df.columns,
        y=df.columns,
        colorbar=dict(title='Pearson Coefficient'),
    )
    
    layout = go.Layout(title=title)
    
    if absolute_bounds:
        heatmap['zmax'] = 1.0
        heatmap['zmin'] = -1.0
        
    fig = go.Figure(data=[heatmap], layout=layout)
    py.iplot(fig)

correlation_heatmap(combined_df_2016.pct_change(), "Cryptocurrency Correlations in 2016")

Dabei stellen dunkelrote Werte eine starke Korrelation dar (jede Münze ist offensichtlich stark mit sich selbst korreliert) und dunkelblaue Werte eine inverse Korrelation. Alle Farben dazwischen – Hellblau/Orange/Grau/Braun – haben Werte, die unterschiedliche Grade schwacher Korrelation bzw. keiner Korrelation darstellen.

Was sagt uns dieses Bild? Auf einer grundlegenden Ebene zeigt es, wie die Preise verschiedener Kryptowährungen im Laufe des Jahres 2016 schwankten, wobei kaum eine statistisch signifikante Korrelation bestand.

Um nun unsere Hypothese zu überprüfen, dass „die Korrelation zwischen Kryptowährungen in den letzten Monaten zugenommen hat“, wiederholen wir denselben Test mit Daten aus dem Jahr 2017.

combined_df_2017 = combined_df[combined_df.index.year == 2017]
combined_df_2017.pct_change().corr(method='pearson')

Name	DASH	ETC	ETH	LTC	SC	STR	XEM	XMR	XRP	BTC
DASH	1.000000	0.384109	0.480453	0.259616	0.191801	0.159330	0.299948	0.503832	0.066408	0.357970
ETC	0.384109	1.000000	0.602151	0.420945	0.255343	0.146065	0.303492	0.465322	0.053955	0.469618
ETH	0.480453	0.602151	1.000000	0.286121	0.323716	0.228648	0.343530	0.604572	0.120227	0.421786
LTC	0.259616	0.420945	0.286121	1.000000	0.296244	0.333143	0.250566	0.439261	0.321340	0.352713
SC	0.191801	0.255343	0.323716	0.296244	1.000000	0.417106	0.287986	0.374707	0.248389	0.377045
STR	0.159330	0.146065	0.228648	0.333143	0.417106	1.000000	0.396520	0.341805	0.621547	0.178706
XEM	0.299948	0.303492	0.343530	0.250566	0.287986	0.396520	1.000000	0.397130	0.270390	0.366707
XMR	0.503832	0.465322	0.604572	0.439261	0.374707	0.341805	0.397130	1.000000	0.213608	0.510163
XRP	0.066408	0.053955	0.120227	0.321340	0.248389	0.621547	0.270390	0.213608	1.000000	0.170070
BTC	0.357970	0.469618	0.421786	0.352713	0.377045	0.178706	0.366707	0.510163	0.170070	1.000000

Sind diese Daten relevanter? Reicht es aus, um als Investitionskriterium zu dienen? Die Antwort ist nein.

Es ist jedoch anzumerken, dass die Vernetzung nahezu aller Kryptowährungen zugenommen hat.

correlation_heatmap(combined_df_2017.pct_change(), "Cryptocurrency Correlations in 2017")

Wie Sie dem Bild oben entnehmen können, wird es immer interessanter.

Warum passiert das?

Gute Frage! Aber die Wahrheit ist, ich bin mir nicht so sicher …

Meine erste Reaktion war, dass Hedgefonds vor Kurzem mit dem öffentlichen Handel auf den Kryptowährungsmärkten begonnen hatten. Diese Fonds halten viel mehr Kapital als der durchschnittliche Trader. Wenn ein Fonds sein Anlagekapital zwischen mehreren Kryptowährungen absichert und dann für jede Währung ähnliche Risikofaktoren basierend auf einer unabhängigen Variable (z. B. dem Aktienmarkt) verwendet, ist er rentabler. Der Handel Strategien. Aus dieser Perspektive betrachtet ist der Trend der zunehmenden Korrelation sinnvoll.

Ein tieferes Verständnis von XRP und STR

Beispielsweise ist aus der obigen Grafik ersichtlich, dass XRP (Ripples Token) die geringste Korrelation mit anderen Kryptowährungen aufweist. Eine bemerkenswerte Ausnahme ist hier jedoch STR (Stellars Token, offiziell „Lumens“ genannt), das eine starke Korrelation mit XRP aufweist (Korrelationskoeffizient: 0,62).

Interessanterweise handelt es sich bei Stellar und Ripple um sehr ähnliche Fintech-Plattformen, die beide darauf abzielen, die umständlichen Schritte bei der grenzüberschreitenden Überweisung von Geld zwischen Banken zu reduzieren. Angesichts der Ähnlichkeit der von Blockchain-Diensten verwendeten Token ist es denkbar, dass einige große Akteure und Hedgefonds ähnliche Handelsstrategien für ihre Investitionen in Stellar und Ripple verwenden. Dies könnte der Grund sein, warum XRP eine stärkere Korrelation mit STR aufweist als andere Kryptowährungen.

Okay, du bist dran!

Die obigen Erklärungen sind größtenteils spekulativ. Möglicherweise können Sie es besser machen. Aufbauend auf dem Fundament, das wir gelegt haben, gibt es Hunderte verschiedener Möglichkeiten, wie Sie die Geschichten in Ihren Daten weiter erforschen können.

Hier sind einige meiner Vorschläge für Leser, die sie bei ihrer Recherche berücksichtigen sollten:

• Hinzufügen von Daten zu weiteren Kryptowährungen zur Gesamtanalyse
• Passen Sie den Zeitbereich und die Granularität der Korrelationsanalyse an, um verfeinerte oder grobkörnigere Ansichten von Trends zu erhalten.
• Finden Sie Trends im Transaktionsvolumen oder Blockchain-Data-Mining. Wenn Sie zukünftige Preisschwankungen vorhersagen möchten, benötigen Sie möglicherweise eher Daten zum Kauf-/Verkaufsvolumenverhältnis als reine Preisdaten.
• Fügen Sie Preisdaten zu Aktien, Rohstoffen und Fiat-Währungen hinzu, um zu bestimmen, welche davon mit Kryptowährungen korreliert sind (aber denken Sie an das alte Sprichwort „Korrelation bedeutet nicht Kausalität“).
• Verwenden Sie Event Registry, GDELT und Google Trends, um die Anzahl der „Hot Words“ rund um eine bestimmte Kryptowährung zu quantifizieren.
• Verwenden Sie die Daten, um ein prädiktives maschinelles Lernmodell zu trainieren, das den Preis von morgen vorhersagt. Wenn Sie ehrgeiziger sind, können Sie das obige Training sogar mit einem rekurrierenden neuronalen Netzwerk (RNN) durchführen.
• Erstellen Sie anhand Ihrer Analyse einen automatisierten Trading-Bot, der über die entsprechende Anwendungsprogrammierschnittstelle (API) auf Börsen-Websites wie „Poloniex“ oder „Coinbase“ verwendet werden kann. Seien Sie vorsichtig: Ein Bot mit schlechter Leistung kann Ihr Vermögen im Handumdrehen vernichten. Es empfiehlt sich die Nutzung der quantitativen Erfinderplattform FMZ.COM.

Das Beste an Bitcoin und digitalen Währungen im Allgemeinen ist ihre dezentrale Natur, die sie freier und demokratischer macht als jedes andere Anlagegut. Geben Sie Ihre Analyse als Open Source frei, engagieren Sie sich in der Community oder schreiben Sie einen Blogbeitrag! Hoffentlich verfügen Sie jetzt über die erforderlichen Fähigkeiten, um Ihre eigene Analyse durchzuführen und in der Lage zu sein, alle spekulativen Artikel über Kryptowährungen, die Sie in Zukunft lesen, kritisch zu hinterfragen, insbesondere die Vorhersagen, die nicht durch Daten gestützt werden. Vielen Dank fürs Lesen. Wenn Sie Anmerkungen, Anregungen oder Kritik zu diesem Tutorial haben, hinterlassen Sie uns gerne eine Nachricht unter https://www.fmz.com/bbs.