Eine datengetriebene Methode zur Analyse von Spekulationen über digitale Währungen

Wie verhält sich der Bitcoin-Preis? Warum steigen und fallen die Preise der digitalen Währungen? Sind die Marktpreise der verschiedenen Kryptowährungen untrennbar miteinander verbunden oder weitgehend unabhängig?

Artikel über digitale Währungen wie Bitcoin und Ethereum sind jetzt voll von Spekulationen, und Hunderte von selbsternannten Experten sprechen sich für die Trends aus, die sie erwarten. Viele dieser Analysen fehlen an einer soliden Grundlage für grundlegende Daten und statistische Modelle.

Das Ziel dieses Artikels ist es, eine einfache Einführung in die Analyse von digitalen Währungen mit Python zu geben. Wir werden Daten über verschiedene digitale Währungen durch ein einfaches Python-Skript abrufen, analysieren und visualisieren. Während wir dies tun, werden wir interessante Trends für diese volatilen Marktverhaltensweisen und ihre Entwicklung entdecken.

Dies ist kein Artikel, der über digitale Währungen spricht, und auch keine Ansicht darüber, welche spezifischen Währungen steigen und welche fallen werden. Vielmehr konzentrieren wir uns in diesem Tutorial darauf, nur Rohdaten zu erhalten und die Geschichten zu entdecken, die in den Zahlen verborgen sind.

Schritt eins: Wir bauen unsere Daten-Arbeitsumgebung auf

Dieses Tutorial ist für Amateure, Ingenieure und Datenwissenschaftler aller Fähigkeitsstufen konzipiert. Egal, ob Sie ein Branchen-Bull oder ein Programmierer sind. Die einzigen Fähigkeiten, die Sie benötigen, sind ein grundlegendes Verständnis der Python-Programmiersprache und ausreichende Kenntnisse der Befehlszeile (für die Einrichtung eines Datenwissenschaftsprojekts).

1.1 Installieren von Inventor Quantitative Hosts und Einrichten von Anaconda

• Ein Qualitätsmanager-System von Erfindern

发明者量化平台FMZ.COM除了提供优质的各大主流交易所的数据源，还提供一套丰富的API接口以帮助我们在完成数据的分析后进行自动化交易。这套接口包括查询账户信息，查询各个主流交易所的高，开，低，收价格，成交量，各种常用技术分析指标等实用工具，特别是对于实际交易过程中连接各大主流交易所的公共API接口，提供了强大的技术支持。

All diese Funktionen sind in einem Docker-ähnlichen System verpackt, und wir müssen nur unsere eigenen Cloud-Dienste kaufen oder leasen, um das Docker-System zu installieren.

In der offiziellen Bezeichnung der Quantifizierungsplattform der Erfinder wird das Docker-System als Host-System bezeichnet.

Über die Implementierung von Administratoren und Roboter lesen Sie in meinem früheren Artikel:https://www.fmz.com/bbs-topic/4140

Leser, die sich einen Cloud-Deployment-Manager kaufen möchten, können sich an diesen Artikel wenden:https://www.fmz.com/bbs-topic/2848

Nachdem wir einen guten Cloud-Dienst und ein gutes Administrator-System erfolgreich bereitgestellt haben, werden wir nun den größten Templar von Python installieren: Anaconda

Der einfachste Weg, um alle hierfür notwendigen Programmierumgebungen (Dependenzen, Versionsmanagement usw.) zu realisieren, ist Anaconda.

Da wir Anaconda auf einem Cloud-Service installieren, empfehlen wir, dass der Cloud-Server die Anaconda-Version für Linux-Systeme mit der Befehlszeile installiert.

Über die Installation von Anaconda lesen Sie im offiziellen Anaconda-Handbuch:https://www.anaconda.com/distribution/

Wenn Sie ein erfahrener Python-Programmierer sind und keine Notwendigkeit haben, Anaconda zu verwenden, ist das völlig in Ordnung. Ich würde annehmen, dass Sie keine Hilfe benötigen, um die notwendigen Abhängigkeiten zu installieren.

1.2 Erstellen einer Anaconda-Datenanalysen-Projektumgebung

Nachdem Anaconda installiert ist, müssen wir eine neue Umgebung erstellen, um unsere Abhängigkeiten zu verwalten.

conda create --name cryptocurrency-analysis python=3

Wir haben eine neue Anaconda-Umgebung für unser Projekt geschaffen.

Dann geben Sie ein.

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

Wir müssen diese Umgebung aktivieren.

Die nächste Eingabe ist:

conda install numpy pandas nb_conda jupyter plotly

Es gibt verschiedene Abhängigkeitspakete, die für die Installation dieses Projekts erforderlich sind.

Hinweis: Warum eine Anaconda-Umgebung verwenden? Wenn Sie viele Python-Projekte auf Ihrem Computer ausführen möchten, ist es hilfreich, Konflikte zwischen den verschiedenen Programmierabhängigkeiten (Softwarelibrary und Paket) zu vermeiden.

1.3 Erstellen Sie ein Jupiter Notebook

Wenn die Umgebung und die Abhängigkeitspakete installiert sind, läuft es.

jupyter notebook

Hier können Sie den Kern von Python starten und dann mit Ihrem Browser auf http://localhost:8888/Wenn Sie ein neues Python-Notebook erstellen, stellen Sie sicher, dass es verwendet wird:

Python [conda env:cryptocurrency-analysis]

Kern

1.4 Import von Abhängigkeitspaketen

Wir bauen ein neues leeres Jupiter-Notebook und dann müssen wir als erstes die nötigen Abhängigkeitspakete importieren.

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

Wir müssen Plotly importieren und Offline-Modus starten.

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: Erhalten Sie Preisinformationen über die Kryptowährung

Die Vorbereitungsarbeiten sind abgeschlossen und wir können nun mit der Auswahl der Daten beginnen, die wir analysieren möchten.

Dies wird für die GetTicker-Funktion verwendet.https://www.fmz.com/api

2.1 Schreiben von Quandl-Sammlungsfunktionen

Um die Datenerfassung zu vereinfachen, haben wir eine Funktion geschrieben, die von Quandl heruntergeladen und synchronisiert wird.quandl.comEs handelt sich um eine kostenlose Finanzdaten-Schnittstelle, die im Ausland eine hohe Bekanntheit genießt. Auch die Quantifizierungsplattform der Erfinder bietet eine ähnliche Daten-Schnittstelle, die hauptsächlich für den Handel in der realen Welt verwendet wird.

Bei Festplattenhandel können die GetTicker- und GetRecords-Funktionen direkt in Python aufgerufen werden, um Preisdaten zu erhalten.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

Hier wird die Datenbank mit Pickle sortiert und die heruntergeladenen Daten als Dateien gespeichert, so dass das Programm nicht jedes Mal, wenn es ausgeführt wird, die gleichen Daten herunterlädt. Die Funktion gibt Daten im Format eines Pandas-Datenrahmens zurück.

2.2 Kryptowährungspreisdaten auf der Kraken Exchange erhalten

Wir nehmen die Kraken-Bitcoin-Börse als Beispiel und beginnen mit dem Bitcoin-Preis, an dem sie erworben wurde.

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

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

btc_usd_price_kraken.head()

Das Ergebnis:

BTC	Geöffnet	Hoch	Niedrig	Schließen	Volumen (BTC)	Volumen (Währung)	Gewichteter Preis
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 machen wir eine einfache Tabelle, um die Richtigkeit der Daten durch visuelle Methoden 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])

这里，我们用Plotly来完成可视化部分。相对于使用一些更成熟的Python数据可视化库，比如Matplotlib，用Plotly是一个不那么普遍的选择，但Plotly确实是一个不错的选择，因为它可以调用D3.js的充分交互式图表。这些图表有非常漂亮的默认设置，易于探索，而且非常方便嵌入到网页中。

Tipp: Vergleichen Sie die generierten Diagramme mit den Bitcoin-Preis-Charts von Mainstream-Börsen (z. B. auf OKEX, Binance oder Huobi) als einen schnellen Integritätscheck, um zu bestätigen, ob die heruntergeladenen Daten im Großen und Ganzen übereinstimmen.

2.3 Erhalten Sie Preisdaten von Bitcoin-Mainstream-Börsen

Ein aufmerksamer Leser hat vielleicht schon bemerkt, dass die Daten in den oben genannten Daten fehlen, insbesondere in den Jahren Ende 2014 und Anfang 2016. Besonders bei der Kraken-Börse ist dies besonders deutlich. Wir wollen natürlich nicht, dass diese fehlenden Daten die Analyse der Preise beeinflussen.

Es ist ein Merkmal der Kryptowährungsbörse, dass die Preise der Währungen durch die Angebots- und Nachfragebeziehungen bestimmt werden. Daher ist es nicht möglich, dass die Preise der einzelnen Transaktionen die wichtigsten Preise des Marktes sind. Um dieses Problem zu lösen, und um das eben erwähnte Problem der fehlenden Daten (möglicherweise aufgrund technischer Unterbrechungen und Datenfehler) zu lösen, werden wir Daten von den drei wichtigsten Bitcoin-Börsen der Welt herunterladen und dann den durchschnittlichen Bitcoin-Preis berechnen.

Lassen Sie uns anfangen, indem wir die Daten der einzelnen Börsen in einen Datensatz von Wörterbuchtypen herunterladen.

# 下载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 einem Datensatz zusammenfassen

Als nächstes definieren wir eine spezielle Funktion, die die gemeinsamen Spalten der einzelnen Datensätze zu einer neuen Datensäule zusammenführt.

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)

Jetzt werden die Preise für alle Datensätze auf Basis der Pivotal-Wert-Arrays zusammengefasst.

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

Schließlich überprüfen wir die letzten fünf Zeilen der zusammengefassten Daten mit der Methode der Schleife, um sicherzustellen, dass die Daten korrekt und vollständig sind.

btc_usd_datasets.tail()

Die Ergebnisse zeigen:

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 man aus der obigen Tabelle sehen kann, entsprechen die Daten unseren Erwartungen, und die Daten umfassen ungefähr die gleiche Bandbreite, nur unterscheiden sie sich geringfügig aufgrund von Verzögerungen oder jeweiligen Merkmalen der einzelnen Börsen.

2.5 Die Visualisierung von Preisdaten

Aus analytischer Logik ist der nächste Schritt, diese Daten durch Visualisierung zu vergleichen. Dafür müssen wir zuerst eine Hilfsfunktion definieren, die durch die Bereitstellung von Einzeilinienbefehlen, die Daten mit einem Diagramm erzeugen, nennt man siedf_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)

Für die einfache Verständnisweise wird in diesem Artikel nicht viel über die Logik dieser Hilfsfunktion diskutiert. Weitere Informationen finden Sie in den offiziellen Anleitungen zu Pandas und Plotly.

Jetzt können wir ganz einfach eine Grafik der Bitcoin-Preisdaten erstellen!

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

2.6 Bereinigung und Addition von Gesamtpreisdaten

Wie aus der obigen Grafik zu sehen ist, gibt es einige unregelmäßige Veränderungen, die wir versuchen werden, zu beseitigen, obwohl die vier Datenserien den gleichen Weg verfolgen.

Wir wissen, dass der Preis von Bitcoin in der Zeit von 2012 bis 2017 nie gleich null war, also haben wir zuerst alle Nullen aus dem Datenfeld entfernt.

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

Nach der Rekonstruktion der Datensätze sehen wir eine klarere Grafik ohne fehlende Daten.

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

Wir können nun 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! Wir zeichnen ihn wieder aus, um zu überprüfen, ob die Daten ein Problem darstellen.

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

Es sieht so aus, als ob es wirklich kein Problem gibt, und wir werden später weiter mit diesen zusammengefassten Preissequenzdaten weitermachen, um die Wechselkurse zwischen anderen Kryptowährungen und dem US-Dollar zu bestimmen.

Schritt 3: Sammeln der Preise für Altcoins

Bis jetzt haben wir Zeitreihen-Daten über den Bitcoin-Preis. Als nächstes werden wir einige Daten über nicht-Bitcoin-Digitalwährungen betrachten, nämlich die Kryptowährungen (Altcoins). Natürlich ist der Begriff Kryptowährung vielleicht ein wenig übertrieben, aber was die Entwicklung der Kryptowährungen betrifft, außer den zehn größten Kryptowährungen (wie Bitcoin, Ethereum, EOS, USDT usw.), sind die meisten von ihnen als Kryptowährungen zu bezeichnen.

3.1 Hilfsfunktionen definieren über die Poloniex-API

Zunächst nutzen wir die API der Poloniex-Börse, um Daten über die Transaktionen von Kryptowährungen zu erhalten. Wir haben zwei Hilfsfunktionen definiert, um die Daten über Kryptowährungen zu erhalten, die hauptsächlich JSON-Daten über die API herunterladen und speichern.

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

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 Polonix API erstellt und die eben definierte Funktion get_json_data aufruft, um die Datenresultate des Anrufs 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 die Zeichencodes für die Pairing von digitalen Währungen (z. B. BTC_ETH-Ketten) und gibt eine Datenscheibe zurück, die die historischen Preise der beiden Währungen enthält.

3.2 Preisdaten von Poloniiex herunterladen

Die meisten Kryptowährungen können nicht direkt in US-Dollar gekauft werden. Um diese Kryptowährungen zu erhalten, müssen die Einzelpersonen normalerweise zuerst Bitcoin kaufen und dann entsprechend dem Preisverhältnis zwischen ihnen in Kryptowährungen umtauschen. Daher müssen wir den Wechselkurs für jede Kryptowährung herunterladen, um Bitcoin umzutauschen, und dann mit den vorhandenen Bitcoin-Preisdaten in US-Dollar umzutauschen.

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

Jetzt haben wir ein Wörterbuch mit neun Datensätzen, die jeweils Daten über den historischen Tagesdurchschnitt zwischen Kryptowährung und Bitcoin enthalten.

Wir können die Daten anhand der letzten Zeilen der Ethereum-Preistabelle beurteilen, ob sie richtig sind.

altcoin_data['ETH'].tail()

ETH	Geöffnet	Hoch	Niedrig	Schließen	Volumen (BTC)	Volumen (Währung)	Gewichteter Preis
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 Vereinheitlichung aller Preisdaten in Dollar

Jetzt können wir die BTC-Zeichen-Wechselkursdaten mit unserem Bitcoin-Preisindex kombinieren, um den historischen Preis für jede Zeichen-Zeiche (einheit: USD) direkt 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 für jede Kryptowährung einen neuen Datensatz hinzu, um ihren entsprechenden Dollarpreis zu speichern.

Anschließend können wir die zuvor definierte Funktion merge_dfs_on_column wieder verwenden, um eine zusammengefasste Datensammlung zu erstellen, die die Dollarpreise für jede digitale Währung integriert.

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

Wir haben es geschafft!

Lassen Sie uns nun gleichzeitig den Bitcoin-Preis als letzten Punkt in die zusammengefasste Datensammlung hinzufügen.

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

Jetzt haben wir die einzigartige Datenbank, die die täglichen Dollarpreise der zehn digitalen Währungen enthält, die wir überprüfen.

Wir haben die vorherige Funktion df_scatter neu aufgerufen, um die entsprechenden Preise aller Kryptowährungen in grafischer Form darzustellen.

Die Grafik sieht gut aus, aber sie gibt uns einen Überblick über die Veränderungen der Wechselkurse für jede digitale Währung in den vergangenen Jahren.

Hinweis: Hier verwenden wir die y-Achse der Logarithmus-Spezifikation, um alle Kryptowährungen auf derselben Grafik zu vergleichen. Sie können auch andere verschiedene Parameterwerte (z. B. scale=linear) ausprobieren, um die Daten aus verschiedenen Perspektiven zu verstehen.

3.4 Beginn der Relevanzanalyse

Ein aufmerksamer Leser wird vielleicht bemerken, dass die Preise der Kryptowährungen, obwohl sie stark voneinander abweichen und sehr unbeständig sind, zusammenhängend zu sein scheinen. Besonders seit dem rasanten Anstieg im April 2017 scheinen sogar viele kleine Schwankungen mit den Schwankungen des gesamten Marktes zusammenzubrechen.

Natürlich ist eine Schlussfolgerung, die von Daten unterstützt wird, überzeugender als eine intuitive Aussage, die auf Bildern basiert.

Wir können die Relativitätshypothese mit der Pandas-Corr () -Funktion verifizieren. Die Prüfmethode berechnet für jede Stufe der Datenhalte die Pearson-Relativität, die für die andere Stufe entspricht.

Änderungen am 22.8.2017: Diese Änderung zielt darauf ab, bei der Berechnung der entsprechenden Koeffizienten den absoluten Wert der täglichen Rendite anstelle des Preises zu verwenden.

Eine direkte Berechnung basierend auf einer nicht-festen Zeitreihe (z. B. Rohpreisdaten) kann zu einer Abweichung der Korrelationskoeffizienten führen. Unsere Lösung für dieses Problem ist die Verwendung der pct_change-Methode, die den absoluten Wert eines jeden Preises in der Datensammlung in die entsprechende Tagesrendite umwandelt.

Zum Beispiel, wenn wir die entsprechenden Koeffizienten für 2016 berechnen.

# 计算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	SCHR	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
SCHR	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 oben stehende Abbildung zeigt alle Koeffizienten. Die Koeffizienten nahe 1 oder -1 bedeuten, dass die Sequenz positiv oder inversiv zusammenhängt. Die Koeffizienten nahe 0 zeigen, dass die entsprechenden Objekte nicht zusammenhängen und ihre Schwankungen unabhängig voneinander sind.

Für bessere Visualisierungsergebnisse haben wir eine neue Visualisierungs-Hilfe-Funktion erstellt.

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")

Hier stehen die dunkelroten Werte für eine starke Korrelation (jede Währung ist eindeutig mit ihrer eigenen Höhe verknüpft) und die dunkelblauen Werte für eine inverse Korrelation. Alle zwischenliegenden Farben - hellblau/rot/grau/braun - repräsentieren unterschiedliche Grade von schwacher Korrelation oder keinerlei Korrelation.

Grundsätzlich zeigt es, dass die Preisschwankungen der verschiedenen Kryptowährungen im Jahr 2016 kaum eine statistisch signifikante Korrelation aufweisen.

Nun, um unsere Hypothese zu verifizieren, dass die Relevanz von Kryptowährungen in den letzten Monaten gestiegen ist, werden wir den gleichen Test mit Daten aus dem Jahr 2017 wiederholen.

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

Name	DASH	ETC	ETH	LTC	SC	SCHR	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
SCHR	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 die oben genannten Daten relevanter? Sind sie ausreichend als Kriterium für Investitionen? Nein.

Es ist jedoch bemerkenswert, dass fast alle digitalen Währungen zunehmend miteinander verknüpft sind.

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

Wie man an der Grafik sehen kann, wird es immer interessanter.

Warum passiert das?

Das ist eine gute Frage, aber ich bin mir nicht ganz sicher, ob ich das tun kann.

Meine erste Reaktion war, dass Hedgefonds kürzlich anfingen, öffentlich auf dem digitalen Währungsmarkt zu handeln. Diese Funds halten viel mehr Kapital als normale Händler, wenn ein Fonds sein Einlagekapital zwischen mehreren digitalen Währungen abdeckt und dann eine ähnliche Handelsstrategie für jede Währung verwendet, basierend auf unabhängigen Variablen (z. B. Aktienmärkte).

Ein tieferes Verständnis von XRP und STR

Aus dem obigen Diagramm ist zum Beispiel deutlich zu erkennen, dass XRP (Ripple-Token) mit anderen digitalen Währungen am wenigsten verwandt ist. Eine bemerkenswerte Ausnahme ist jedoch STR (Stellar-Token, offiziell "Lumens" genannt), die eine starke Verwandtschaft mit XRP (Verwandtschaftskoeffizient: 0.62) hat.

Interessanterweise sind Stellar und Ripple sehr ähnliche Fintech-Plattformen, die beide darauf abzielen, die peinlichen Schritte bei transnationalen Transfers zwischen Banken zu reduzieren. Verständlicherweise könnten einige große Spieler und Hedgefonds aufgrund der Ähnlichkeit von Blockchain-Diensten, die Token verwenden, ähnliche Handelsstrategien für ihre Investitionen in Stellar und Ripple verwenden. Dies könnte der Grund sein, warum XRP im Vergleich zu anderen digitalen Währungen stärker mit STR verknüpft ist.

Gut, jetzt bist du dran!

Die oben genannten Erklärungen sind weitgehend spekulativ, und vielleicht tun Sie es besser. Auf der Grundlage dessen, was wir bereits gelegt haben, haben Sie hunderte oder tausende verschiedene Möglichkeiten, die Geschichten in den Daten weiter zu erkunden.

Hier sind einige meiner Vorschläge, die die Leser dazu verweisen können, in diese Richtungen voranzukommen:

• Mehr Daten über digitale Währungen hinzugefügt für die gesamte Analyse
• Anpassung des Zeitraums und der Partikelzahl der Korrelationsanalyse für eine optimierte oder grob partikelhafte Trendansicht.
• Trends aus Handelsvolumen oder Blockchain-Daten suchen. Im Vergleich zu den ursprünglichen Preisdaten benötigen Sie möglicherweise mehr Kauf-/Verkaufsquote-Daten, wenn Sie zukünftige Preisfluktuationen vorhersagen möchten.
• Hinzufügen von Preisdaten zu Aktien, Waren und Währungen, um zu entscheiden, welche von ihnen mit digitalen Währungen verknüpft sind.
• Verwenden Sie Event Registry, GDELT und Google Trends, um die Anzahl der heißen Wörter um eine bestimmte Kryptowährung zu quantifizieren.
• Nutzen Sie die Daten, um ein vorausschauendes Machine-Learning-Modell zu trainieren, um die Preise von morgen vorherzusagen.
• Nutzen Sie Ihre Analysen, um einen automatisierten Handelsroboter zu erstellen, der über eine entsprechende Application Programming Interface (API) auf einer Börsenseite wie Polonix oder Coinbase angewendet wird.这里推荐使用发明者量化平台FMZ.COM。

Das Beste an Bitcoin, und an der digitalen Währung im Allgemeinen, ist ihre dezentrale Natur, die sie freier und demokratischer macht als jede andere Assets. Du kannst deine Analysen mit Open Source teilen, an der Community teilnehmen oder einen Blog schreiben! Hoffentlich hast du jetzt die Fähigkeiten, die du benötigst, um selbst zu analysieren, und die Fähigkeit, dich in der Zukunft zu diskutieren, wenn du irgendeinen spekulativen Artikel über digitale Währungen liest, insbesondere solche, die keine datenunterstützten Prognosen haben.https://www.fmz.com/bbsIch bin nicht derjenige, der das sagt.

Verwandt

Mehr