Un enfoque basado en datos para analizar la especulación con monedas digitales

¿Cómo se comporta el precio de Bitcoin? ¿Qué hace que los precios de las criptomonedas suban y caigan? ¿Los precios de mercado de diferentes altcoins están inextricablemente vinculados entre sí o son en gran medida independientes? ¿Cómo podemos predecir lo que sucederá a continuación?

Los artículos sobre monedas digitales, como Bitcoin y Ethereum, ahora están plagados de especulaciones, con cientos de autoproclamados expertos que abogan por las tendencias que esperan que surjan. Lo que falta en muchos de estos análisis es una base sólida de datos y modelos estadísticos subyacentes.

El objetivo de este artículo es proporcionar una introducción simple al análisis de criptomonedas utilizando Python. Revisaremos un script de Python simple para recuperar, analizar y visualizar datos de diferentes criptomonedas. A lo largo del camino, descubriremos tendencias interesantes en el comportamiento de estos mercados volátiles y cómo se desarrollan.

Este no es un artículo que explique las criptomonedas ni es una pieza de opinión sobre qué monedas específicas subirán y cuáles bajarán. En cambio, nuestro enfoque en este tutorial es simplemente tomar los datos sin procesar y descubrir las historias ocultas en los números.

Paso 1: Construir nuestro entorno de trabajo de datos

Este tutorial está diseñado para entusiastas, ingenieros y científicos de datos de todos los niveles. Ya sea que sea un experto en la industria o un novato en programación, las únicas habilidades que necesita son una comprensión básica del lenguaje de programación Python y un conocimiento suficiente de las operaciones de línea de comandos. (Simplemente poder configurar un proyecto de ciencia de datos).

1.1 Instalar Inventor Quant Host y configurar Anaconda

• Inventor del sistema de custodia cuantificada

Además de proporcionar fuentes de datos de alta calidad de los principales intercambios convencionales, la plataforma cuantitativa Inventor FMZ.COM también proporciona un amplio conjunto de interfaces API para ayudarnos a realizar transacciones automatizadas después de completar el análisis de datos. Este conjunto de interfaces incluye herramientas prácticas como la consulta de información de cuentas, la consulta de precios altos, de apertura, bajos y de cierre, el volumen de operaciones, varios indicadores de análisis técnico comúnmente utilizados de varios intercambios principales, etc., especialmente para conectarse a los principales intercambios principales en tiempo real. Procesos comerciales. La interfaz API pública proporciona un soporte técnico potente.

Todas las funciones mencionadas anteriormente están encapsuladas en un sistema similar a Docker. Todo lo que tenemos que hacer es comprar o alquilar nuestro propio servicio de computación en la nube y luego implementar el sistema Docker.

En el nombre oficial de Inventor Quantitative Platform, este sistema Docker se denomina sistema host.

Para obtener más información sobre cómo implementar hosts y robots, consulte mi artículo anterior: https://www.fmz.com/bbs-topic/4140

Los lectores que quieran comprar su propio servidor de implementación de computación en la nube pueden consultar este artículo: https://www.fmz.com/bbs-topic/2848

Después de implementar con éxito el servicio de computación en la nube y el sistema host, instalaremos la herramienta Python más poderosa: Anaconda

Para lograr todos los entornos de programa relevantes necesarios para este artículo (bibliotecas dependientes, gestión de versiones, etc.), la forma más sencilla es utilizar Anaconda. Es un ecosistema de ciencia de datos Python empaquetado y un administrador de dependencias.

Dado que estamos instalando Anaconda en un servicio en la nube, le recomendamos que instale el sistema Linux más la versión de línea de comandos de Anaconda en el servidor en la nube.

Para conocer el método de instalación de Anaconda, consulte la guía oficial de Anaconda: https://www.anaconda.com/distribution/

Si eres un programador Python experimentado y no sientes la necesidad de usar Anaconda, no hay problema. Asumiré que no necesitas ayuda para instalar las dependencias necesarias y puedes pasar a la Parte 2.

1.2 Crear un entorno de proyecto de análisis de datos de Anaconda

Después de instalar Anaconda, necesitamos crear un nuevo entorno para administrar nuestros paquetes de dependencia. En la interfaz de línea de comandos de Linux, ingresamos:

conda create --name cryptocurrency-analysis python=3

Vamos a crear un nuevo entorno Anaconda para nuestro proyecto.

A continuación, ingrese

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

Para activar este entorno

A continuación, introduzca:

conda install numpy pandas nb_conda jupyter plotly

Para instalar los distintos paquetes de dependencia necesarios para este proyecto.

Nota: ¿Por qué utilizar el entorno Anaconda? Si planea ejecutar muchos proyectos de Python en su computadora, es útil separar las dependencias (bibliotecas y paquetes) de diferentes proyectos para evitar conflictos. Ananconda crea un directorio de entorno especial para el paquete de dependencia de cada proyecto, de modo que todos los paquetes puedan administrarse y distinguirse adecuadamente.

1.3 Crear un cuaderno Jupyter

Después de instalar los paquetes de entorno y dependencia, ejecute

jupyter notebook

Para iniciar el kernel de iPython, apunte su navegador a http://localhost:8888/ y cree un nuevo cuaderno de Python, asegurándose de que use:

Python [conda env:cryptocurrency-analysis]

Núcleo

1.4 Importación de paquetes dependientes

Crea un nuevo cuaderno Jupyter vacío y lo primero que debemos hacer es importar los paquetes de dependencia necesarios.

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

También necesitamos importar Plotly y habilitar el modo sin conexión

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

Paso 2: Obtenga información sobre el precio de la moneda digital

Ahora que los preparativos están completos, podemos comenzar a adquirir los datos para analizar. Primero, necesitamos utilizar la interfaz API de la plataforma cuantitativa Inventor para obtener datos del precio de Bitcoin.

Para ello, se utilizará la función GetTicker. Para obtener más información sobre el uso de estas dos funciones, consulte: https://www.fmz.com/api

2.1 Escribir la función de recopilación de datos de Quandl

Para facilitar la adquisición de datos, necesitamos escribir una función para descargar y sincronizar datos de Quandl (quandl.com). Se trata de una interfaz de datos financieros gratuita y muy conocida en el extranjero. La plataforma cuantitativa Inventor también ofrece una interfaz de datos similar, que se utiliza principalmente para transacciones en tiempo real. Dado que este artículo está destinado principalmente al análisis de datos, aquí seguimos utilizando los datos de Quandl.

Al operar en tiempo real, puede llamar directamente a las funciones GetTicker y GetRecords en Python para obtener datos de precios. Para su uso, consulte: 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

La biblioteca pickle se utiliza aquí para serializar los datos y guardar los datos descargados como un archivo, de modo que el programa no vuelva a descargar los mismos datos cada vez que se ejecuta. Esta función devolverá los datos en formato Pandas Dataframe. Si no está familiarizado con el concepto de marco de datos, piense en él como una poderosa hoja de cálculo de Excel.

2.2 Obtención de datos de precios de criptomonedas desde el exchange Kraken

Utilicemos el intercambio de Bitcoin Kraken como ejemplo y comencemos obteniendo su precio de Bitcoin.

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

Utilice el método head() para ver las primeras cinco filas del marco de datos.

btc_usd_price_kraken.head()

El resultado es:

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

A continuación, necesitamos crear una tabla simple para verificar la exactitud de los datos a través de la visualización.

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

Aquí utilizamos Plotly para completar la parte de visualización. Plotly es una opción menos común que usar algunas de las bibliotecas de visualización de datos de Python más maduras, como Matplotlib, pero es una buena opción porque puede recurrir a D3.js para obtener gráficos totalmente interactivos. Los gráficos tienen configuraciones predeterminadas muy agradables, son fáciles de explorar y son muy convenientes para integrar en páginas web.

Consejo: puedes comparar el gráfico generado con un gráfico de precios de Bitcoin de un exchange importante (como el de OKEX, Binance o Huobi) como una comprobación rápida para confirmar que los datos descargados son aproximadamente consistentes.

2.3 Obtención de datos de precios de los principales exchanges de Bitcoin

Los lectores atentos pueden haber notado que faltan datos en los datos anteriores, especialmente a fines de 2014 y principios de 2016. Esta brecha de datos es particularmente evidente en el intercambio Kraken. Ciertamente no queremos que estos datos faltantes afecten nuestro análisis de precios.

La característica de los intercambios de monedas digitales es que el precio de la moneda está determinado por la oferta y la demanda. Por lo tanto, ningún precio de transacción puede convertirse en el “precio principal” del mercado. Para abordar este problema, así como el problema de datos faltantes mencionado anteriormente (posiblemente debido a interrupciones técnicas y errores de datos), descargaremos datos de los tres principales intercambios de Bitcoin en el mundo y calcularemos el precio promedio de Bitcoin.

Comencemos descargando los datos de cada intercambio en un marco de datos que consta de un tipo de diccionario.

# 下载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 Integrar todos los datos en un solo marco de datos

A continuación, definiremos una función especial para fusionar las columnas comunes de cada marco de datos en un nuevo marco de datos. Llamémosla función merge_dfs_on_column

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)

Ahora, combine todos los marcos de datos en función de la columna de “precio ponderado” de cada conjunto de datos.

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

Finalmente, utilizamos el método “tail()” para ver las últimas cinco filas de los datos fusionados para garantizar que los datos sean correctos y completos.

btc_usd_datasets.tail()

El resultado es:

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

Como puede ver en la tabla anterior, estos datos coinciden con nuestras expectativas. El rango de datos es aproximadamente el mismo, pero hay ligeras diferencias en función de la latencia o las características de cada exchange.

2.5 Proceso de visualización de datos de precios

Desde la perspectiva de la lógica analítica, el siguiente paso es comparar estos datos a través de la visualización. Para ello, primero debemos definir una función auxiliar que utilice los datos para crear un gráfico mediante un comando de una sola línea. La llamaremos función 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)

Para su fácil comprensión, este artículo no analizará en detalle el principio lógico de esta función auxiliar. Si desea obtener más información, consulte la documentación oficial de Pandas y Plotly.

¡Ahora podemos crear fácilmente gráficos de datos de precios de Bitcoin!

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

2.6 Datos de precios limpios y agregados

Como se puede ver en el gráfico anterior, aunque las cuatro series siguen aproximadamente la misma trayectoria, hay algunas irregularidades en ellas que intentaremos aclarar.

En el período de 2012-2017, sabemos que el precio de Bitcoin nunca ha sido igual a cero, por lo que primero eliminamos todos los valores cero en el marco de datos.

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

Después de reconstruir el marco de datos, podemos ver un gráfico mucho más claro sin datos faltantes.

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

Ahora podemos calcular una nueva columna: el precio diario promedio de Bitcoin en todos los intercambios.

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

¡La nueva columna es el índice de precios de Bitcoin! Vamos a trazarlo nuevamente para verificar si parece haber algo incorrecto con los datos.

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

Parece que no hay ningún problema y continuaremos utilizando estos datos de series de precios agregados más adelante para poder determinar el tipo de cambio entre otras criptomonedas y el dólar estadounidense.

Paso 3: Recopilar los precios de las altcoins

Hasta ahora, tenemos datos de series temporales de los precios de Bitcoin. A continuación, veamos algunos datos sobre las monedas digitales distintas de Bitcoin, es decir, las altcoins. Por supuesto, el término altcoin puede ser un poco fuerte, pero en cuanto al desarrollo actual de las monedas digitales, además del ranking de capitalización de mercado, la mayoría de las Las diez principales (como Bitcoin, Ethereum, EOS, USDT, etc.) pueden llamarse altcoins. No hay problema. Debemos tratar de mantenernos alejados de estas monedas cuando operamos porque son demasiado confusas y engañosas.

3.1 Definición de funciones auxiliares a través de la API de intercambio de Poloniex

En primer lugar, utilizamos la API del intercambio Poloniex para obtener información sobre las transacciones de moneda digital. Definimos dos funciones auxiliares para obtener los datos relevantes de las altcoins. Estas dos funciones descargan y almacenan en caché principalmente datos JSON a través de la API.

Primero, definimos la función get_json_data, que descargará y almacenará en caché datos JSON de una URL determinada.

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

A continuación, definimos una nueva función que realizará una solicitud HTTP a la API de Poloniex y llamará a la función get_json_data que acabamos de definir para guardar el resultado de la llamada.

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

La función anterior extraerá el código de cadena del par de criptomonedas (como “BTC_ETH”) y devolverá un marco de datos que contiene los precios históricos de ambas monedas.

3.2 Descarga de datos de precios de transacciones de Poloniex

La mayoría de las altcoins no se pueden comprar directamente con dólares estadounidenses. Si las personas quieren obtener estas monedas digitales, generalmente primero tienen que comprar bitcoins y luego cambiarlos por altcoins según la relación de precios entre ellos. Por lo tanto, tenemos que descargar el tipo de cambio de cada moneda digital a Bitcoin, y luego utilizar los datos de precios de Bitcoin existentes para convertirlos a dólares estadounidenses. Descargaremos datos de transacciones de las 9 criptomonedas principales: Ethereum, Litecoin, Ripple, EthereumClassic, Stellar, Dash, Siacoin, Monero y 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

Ahora tenemos un diccionario que contiene 9 marcos de datos, cada uno de los cuales contiene datos históricos de precios promedio diarios entre altcoins y Bitcoin.

Podemos determinar si los datos son correctos mirando las últimas filas de la tabla de precios de Ethereum.

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 Todos los datos de precios deben expresarse en dólares estadounidenses.

Ahora podemos combinar los datos del tipo de cambio de BTC a altcoin con nuestro índice de precios de Bitcoin para calcular directamente el precio histórico de cada altcoin en USD.

# 将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']

Aquí, agregamos una nueva columna al marco de datos para cada altcoin para almacenar su precio en USD correspondiente.

A continuación, podemos reutilizar la función merge_dfs_on_column que definimos anteriormente para crear un marco de datos fusionado que integre el precio en USD de cada criptomoneda.

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

¡Hecho!

Ahora agreguemos también el precio de Bitcoin como última columna al marco de datos fusionado.

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

Ahora tenemos un marco de datos único que contiene los precios diarios en USD de las diez criptomonedas que estamos validando.

Llamamos nuevamente a la función anterior df_scatter para mostrar los precios correspondientes de todas las altcoins en forma de gráfico.

El gráfico se ve bien y nos brinda una imagen completa de cómo ha cambiado el precio de cambio de cada criptomoneda en los últimos años.

Nota: Aquí hemos utilizado un eje y logarítmico para comparar todas las criptomonedas en el mismo gráfico. También puede probar diferentes valores de parámetros (como escala = ‘lineal’) para comprender los datos desde diferentes perspectivas.

3.4 Iniciar análisis de correlación

Los lectores atentos habrán notado que los precios de las monedas digitales parecen estar correlacionados, aunque sus valores monetarios varían ampliamente y son altamente volátiles. Especialmente desde el rápido aumento de abril de 2017, incluso muchas pequeñas fluctuaciones parecen ocurrir en sincronía con las fluctuaciones de todo el mercado.

Por supuesto, las conclusiones respaldadas por datos son más convincentes que la intuición basada en imágenes.

Podemos utilizar la función corr() de Pandas para verificar la hipótesis de correlación anterior. Esta prueba calcula el coeficiente de correlación de Pearson para cada columna del marco de datos con todas las demás columnas.

Nota de revisión del 22/8/2017: Esta sección se modificó para utilizar retornos diarios en lugar de precios absolutos al calcular los coeficientes de correlación.

El cálculo directo basado en una serie temporal no sólida (como datos de precios brutos) puede provocar desviaciones en el coeficiente de correlación. Nuestra solución a este problema es utilizar el método pct_change() para convertir el valor absoluto de cada precio en el marco de datos en la tasa de retorno diaria correspondiente.

Por ejemplo, calculemos el coeficiente de correlación para 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

El gráfico anterior muestra los coeficientes de correlación. Un coeficiente cercano a 1 o -1 significa que la secuencia está correlacionada positiva o inversamente, respectivamente. Un coeficiente de correlación cercano a 0 significa que los objetos correspondientes no están correlacionados y sus fluctuaciones son independientes entre sí.

Para visualizar mejor los resultados, creamos una nueva función auxiliar de visualización.

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

Aquí, los valores de color rojo oscuro representan una fuerte correlación (cada moneda está obviamente altamente correlacionada consigo misma) y los valores de color azul oscuro representan una correlación inversa. Todos los colores intermedios (azul claro, naranja, gris y marrón) tienen valores que representan distintos grados de correlación débil o nula.

¿Qué nos dice esta imagen? En un nivel básico, muestra cómo fluctuaron los precios de diferentes criptomonedas a lo largo de 2016, con poca correlación estadísticamente significativa.

Ahora, para verificar nuestra hipótesis de que “las criptomonedas se han vuelto más correlacionadas en los últimos meses”, repetiremos la misma prueba utilizando datos de 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

¿Son estos datos más relevantes? ¿Es suficiente para servir como criterio de inversión? La respuesta es no.

Vale la pena señalar, sin embargo, que casi todas las criptomonedas están cada vez más interconectadas.

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

Como puedes ver en la imagen de arriba, las cosas se están poniendo cada vez más interesantes.

¿Por qué sucede esto?

¡Buena pregunta! Pero la verdad es que no estoy tan seguro…

Mi primera reacción fue que los fondos de cobertura habían comenzado recientemente a cotizar públicamente en los mercados de criptomonedas. Estos fondos tienen mucho más capital que el operador promedio. Si un fondo cubre su capital de inversión entre múltiples criptomonedas y luego utiliza factores de riesgo similares para cada moneda en función de una variable independiente (por ejemplo, el mercado de valores), será más rentable. estrategias. Si se considera desde esta perspectiva, la tendencia de creciente correlación tiene sentido.

Una comprensión más profunda de XRP y STR

Por ejemplo, del gráfico anterior se desprende claramente que XRP (el token de Ripple) es el que tiene la menor correlación con otras criptomonedas. Pero una excepción notable aquí es STR (el token de Stellar, oficialmente llamado “Lumens”), que tiene una fuerte correlación con XRP (coeficiente de correlación: 0,62).

Curiosamente, Stellar y Ripple son plataformas fintech muy similares y ambas tienen como objetivo reducir los engorrosos pasos que implica transferir dinero entre bancos a través de las fronteras. Es concebible que algunos grandes jugadores y fondos de cobertura utilicen estrategias comerciales similares para sus inversiones en Stellar y Ripple, dada la similitud de los tokens utilizados por los servicios de blockchain. Esta puede ser la razón por la que XRP tiene una correlación más fuerte con STR que otras criptomonedas.

¡Está bien, es tu turno!

Las explicaciones anteriores son en gran medida especulativas, y es posible que puedas hacerlo mejor. Sobre la base que hemos establecido, hay cientos de formas diferentes en las que puede seguir explorando las historias de sus datos.

A continuación se presentan algunas de mis sugerencias para que los lectores las consideren en sus orientaciones de investigación:

• Agregar datos sobre más criptomonedas al análisis general
• Ajuste el rango de tiempo y la granularidad del análisis de correlación para obtener vistas refinadas o de grano grueso de las tendencias.
• Encuentre tendencias en el volumen de transacciones o minería de datos de blockchain. Si desea predecir futuras fluctuaciones de precios, es posible que necesite datos de relación de volumen de compra/venta más que datos de precios brutos.
• Agregue datos de precios de acciones, materias primas y monedas fiduciarias para determinar cuáles de ellas están correlacionadas con las criptomonedas (pero recuerde el viejo dicho “la correlación no implica causalidad”)
• Utilice Event Registry, GDELT y Google Trends para cuantificar la cantidad de “palabras clave” que rodean a una criptomoneda en particular.
• Utilice los datos para entrenar un modelo de aprendizaje automático predictivo para predecir el precio de mañana. Si te sientes más ambicioso, incluso podrías considerar intentar realizar el entrenamiento mencionado anteriormente con una red neuronal recurrente (RNN).
• Utilice su análisis para crear un bot comercial automatizado que pueda utilizarse en sitios web de intercambio como “Poloniex” o “Coinbase” a través de la interfaz de programación de aplicaciones (API) correspondiente. Tenga cuidado: un bot de bajo rendimiento puede eliminar fácilmente sus activos en un instante. Se recomienda utilizar la plataforma cuantitativa del inventor FMZ.COM.

Lo mejor de Bitcoin, y de las monedas digitales en general, es su naturaleza descentralizada, que las hace más libres y democráticas que cualquier otro activo. ¡Comparte tu análisis como código abierto, participa en la comunidad o escribe una publicación de blog! Con suerte, ahora tienes las habilidades que necesitas para realizar tu propio análisis y poder pensar críticamente sobre cualquier artículo especulativo sobre criptomonedas que leas en el futuro, especialmente aquellas predicciones que no están respaldadas por datos. Gracias por leer. Si tienes algún comentario, sugerencia o crítica sobre este tutorial, déjanos un mensaje en https://www.fmz.com/bbs.