Un método de análisis especulativo de moneda digital impulsado por datos

¿Cómo se comporta el precio de Bitcoin? ¿Cuáles son las razones por las que el precio de la moneda digital sube y baja? ¿Están los precios de mercado de las diferentes monedas cómodas inseparablemente relacionados o son en gran medida independientes?

Los artículos sobre monedas digitales como Bitcoin y Ethereum están ahora llenos de especulaciones, con cientos de personas que se hacen llamar expertos que abogan por las tendencias que esperan que surjan. Muchos de estos análisis carecen de una base sólida de datos básicos y modelos estadísticos.

El objetivo de este artículo es proporcionar una breve introducción al análisis de monedas digitales con Python. Recuperaremos, analizaremos y visualizaremos datos de diferentes monedas digitales a través de un sencillo script de Python. En el proceso, descubriremos estos comportamientos de mercado volátiles y las tendencias interesantes de cómo evolucionan.

Este no es un artículo que explique las monedas digitales, ni un punto de vista sobre cuáles monedas en particular subirán y cuáles bajarán. En cambio, en este tutorial nos centraremos en obtener datos primarios y descubrir las historias ocultas en los números.

El primer paso: construir nuestro entorno de trabajo de datos.

Este tutorial está diseñado para aficionados, ingenieros y científicos de datos de todos los niveles de habilidad, ya sea que seas un gran profesional o un pequeño programador, las únicas habilidades que necesitas son un conocimiento básico del lenguaje de programación Python y suficiente conocimiento de las operaciones de la línea de comandos (para poder configurar un proyecto de ciencia de datos).

1.1 Instalar el administrador de cuantificación de inventores y configurar Anaconda

• Sistema de administradores cuantificado por el inventor

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

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

En el nombre oficial de la plataforma de cuantificación de los inventores, este sistema Docker se conoce como sistema administrador.

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

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

Después de haber implementado con éxito un buen sistema de servidores y administradores en la nube, ahora vamos a instalar el mayor templo de Python: Anaconda.

Para implementar todos los entornos de programación relacionados que se requieren en este artículo (la librería de dependencias, la administración de versiones, etc.), el método más sencillo es usar Anaconda. Es un ecosistema de ciencias de datos Python y un administrador de librería de dependencias.

Dado que estamos instalando Anaconda en un servicio en la nube, recomendamos que los servidores en la nube instalen una versión de Anaconda para sistemas Linux con línea de comandos.

Para más información sobre cómo instalar Anaconda, consulte el manual oficial de Anaconda:https://www.anaconda.com/distribution/

Si usted es un programador Python experimentado y no siente la necesidad de usar Anaconda, no hay ningún problema.

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

Una vez que Anaconda está instalado, necesitamos crear un nuevo entorno para administrar nuestros paquetes de dependencias. En la interfaz de la línea de comandos de Linux, escribimos:

conda create --name cryptocurrency-analysis python=3

Para crear un nuevo entorno de Anaconda para nuestro proyecto.

Ahora, el siguiente paso es introducir

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

Para activar este entorno

Ahora, escriba:

conda install numpy pandas nb_conda jupyter plotly

Los paquetes de dependencia necesarios para instalar este proyecto.

Nota: ¿Por qué usar un entorno Anaconda? Si usted tiene la intención de ejecutar muchos proyectos de Python en su computadora, es útil separar los paquetes de dependencia de los diferentes proyectos (librería y paquetes) para evitar conflictos.

1.3 Cómo crear un Notebook de Jupyter

Cuando el entorno y los paquetes de dependencia están instalados, se ejecutan.

jupyter notebook

Para iniciar el núcleo de iPython, visite http:// con su navegadorlocalhost:8888/Para crear un nuevo cuaderno de Python, asegúrese de usar:

Python [conda env:cryptocurrency-analysis]

El núcleo

1.4 Importar paquetes de dependencia

Construimos un nuevo portátil Jupiter vacío y lo primero que hacemos 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 activar el modo fuera de línea.

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: obtener información sobre el precio de la moneda digital

El trabajo de preparación está terminado y ahora podemos comenzar a obtener los datos para analizar. Primero, vamos a obtener datos de precios de Bitcoin con la interfaz API de la plataforma de cuantificación de inventores.

Esto hará uso de la función GetTicker, para más información sobre el uso de estas dos funciones, vea:https://www.fmz.com/api

2.1 Escribir una función de recopilación de datos en Quandl

Para facilitar la obtención de datos, hemos escrito una función para descargar y sincronizar desde Quandl.quandl.comLos datos de Quandl.com son una interfaz de datos financieros gratuita, con una gran popularidad en el extranjero. La plataforma de cuantificación de inventores también ofrece una interfaz de datos similar, principalmente para operaciones en vivo, ya que este artículo se centra principalmente en el análisis de datos.

Cuando se negocia en vivo, se pueden llamar directamente a las funciones GetTicker y GetRecords en Python para obtener datos de precios.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

Aquí se utiliza la librería de picles para ordenar los datos y guardar los datos descargados en un archivo, de modo que el programa no descargue el mismo dato cada vez que se ejecuta. Esta función devuelve datos en formato Dataframe de Panda. Si no está muy familiarizado con el concepto de Dataframe, puede imaginarlo como un tipo de hoja de Excel potente.

2.2 Obtener datos de precios de las monedas digitales de Kraken

Tomemos como ejemplo el intercambio Kraken Bitcoin, comenzando con el precio de Bitcoin que se obtiene.

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

Para ver las primeras cinco líneas del cuadro de datos, use el método head ().

btc_usd_price_kraken.head()

El resultado fue:

El valor de las acciones	Abierto.	En alto.	Bajo	Muy cerca.	Volumen (BTC)	Variación de las tarifas	Precio ponderado
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

El siguiente paso es hacer una simple tabla para verificar la corrección de los datos mediante métodos visuales.

# 做出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的充分交互式图表。这些图表有非常漂亮的默认设置，易于探索，而且非常方便嵌入到网页中。

Un pequeño consejo: puede comparar los gráficos generados con los gráficos de precios de Bitcoin de los intercambios principales (como los gráficos en OKEX, Binance o Huobi) como una rápida comprobación de integridad para confirmar si los datos descargados coinciden en general.

2.3 Obtener datos de precios de los principales intercambios de Bitcoin

Un lector atento puede haber notado que hay una falta de datos en los datos anteriores, especialmente a finales de 2014 y principios de 2016; especialmente en la bolsa Kraken, esta falta de datos es particularmente evidente.

La característica de los intercambios de divisas digitales es que la relación de oferta y demanda determina el precio de las monedas. Por lo tanto, ningún precio de transacción puede convertirse en el precio dominante del mercado. Para resolver este problema, y el problema de falta de datos que acabamos de mencionar (posiblemente debido a interrupciones técnicas y errores en los datos), descargaremos datos de los tres principales intercambios de bitcoins del mundo y calcularemos el precio promedio de bitcoin.

Comencemos por descargar los datos de cada una de las bolsas en una pila de datos compuesta por tipos 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 una pila de datos

En el siguiente paso, vamos a definir una función especial para combinar las columnas compartidas en las columnas de datos en una nueva columna de datos.

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, los precios de los parámetros agregados basados en los diferentes conjuntos de datos se agrupan y se integran todos los parámetros.

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

Por último, utilizamos el método de la cola de cola para revisar las últimas cinco líneas de datos después de la combinación para asegurarnos de que los datos son correctos e integrales.

btc_usd_datasets.tail()

Los resultados muestran:

El valor de las acciones	BITSTAMP	Cuentas de cambio	El ITBIT	- ¿ Por qué?
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 se puede ver en la tabla de arriba, los datos están de acuerdo con lo que esperábamos, con un rango de datos más o menos similar, pero con ligeras diferencias basadas en el retraso de los intercambios o en sus respectivas características.

2.5 Proceso de visualización de los datos de precios

Desde el punto de vista de la lógica analítica, el siguiente paso es comparar estos datos mediante visualización. Para ello, primero necesitamos definir una función auxiliar, la funcióndf_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 facilitar su comprensión, este artículo no explorará demasiado los principios lógicos de esta función auxiliar. Para obtener más información, consulte los documentos de instrucción oficiales de Pandas y Plotly.

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

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

2.6 Limpiar y agregar datos de precios totales

Como se puede ver en el gráfico anterior, aunque las cuatro series de datos siguen más o menos el mismo camino, todavía hay algunos cambios irregulares en ellas, y vamos a tratar de eliminar estos cambios irregulares.

En el período 2012-2017, sabemos que el precio de Bitcoin nunca fue igual a cero, por lo que primero eliminamos todos los ceros del cuadro de datos.

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

Después de reconstruir el mosaico de datos, podemos ver gráficos más claros sin datos perdidos.

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

Ahora podemos calcular una nueva columna: el precio promedio diario 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! ¡Lo dibujamos para comprobar si hay algún problema en el aspecto de 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 realmente no hay problemas, y más adelante continuaremos usando este conjunto de datos de la secuencia de precios para poder determinar los tipos de cambio entre otras monedas digitales y el dólar.

El tercer paso: recoger los precios de las altcoins.

Hasta ahora, ya tenemos los datos de la secuencia de tiempo del precio de Bitcoin. A continuación, vamos a ver algunos datos de las monedas digitales que no son Bitcoin, es decir, las altcoins, por supuesto, el término altcoin puede ser un poco exagerado, pero en lo que respecta a la evolución de las monedas digitales en la actualidad, excepto las monedas de valor de mercado de los diez primeros lugares (como Bitcoin, Ethereum, EOS, USDT, etc.), la mayoría de las cuales pueden llamarse monedas azules no es un problema, y deberíamos alejarnos de estas monedas cuando negociemos, ya que son demasiado confusas y engañosas.

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

Primero, utilizamos la API de Poloniex para obtener información de transacciones de monedas digitales. Hemos definido dos funciones auxiliares para obtener datos relacionados con las monedas digitales, que se basan principalmente en la descarga y el almacenamiento de datos JSON a través de la API.

Primero, definimos la función get_json_data, que descargará y almacenará datos JSON desde una URL dada.

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 generará una solicitud HTTP de la API de Poloniex y llamará a la función get_json_data que acabamos de definir para guardar los resultados 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 extrae el código de caracteres de la pareja de monedas digitales (por ejemplo, el par BTC_ETH) y devuelve el par de datos que contiene los precios históricos de las dos monedas.

3.2 Descargar datos de precios de las transacciones desde Poloniex

La mayoría de las monedas digitales no se pueden comprar directamente con dólares, y los individuos que desean obtener estas monedas digitales generalmente deben comprar bitcoins primero y luego cambiarlos por monedas digitales según la proporción de precios entre ellos. Por lo tanto, tenemos que descargar el tipo de cambio de cada moneda digital para cambiar bitcoins y luego convertirlos en dólares con los datos de precios de bitcoin existentes.

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 con nueve bloques de datos, cada uno con datos de precios promedio diarios históricos entre monedas criptográficas y bitcoins.

Podemos determinar si los datos son correctos a través de las últimas líneas de la tabla de precios de Ethereum.

altcoin_data['ETH'].tail()

ETH	Abierto.	En alto.	Bajo	Muy cerca.	Volumen (BTC)	Variación de las tarifas	Precio ponderado
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 Unificar todas las monedas de los precios en dólares

Ahora, podemos combinar los datos de cambio de BTC a las monedas digitales con nuestro índice de precios de Bitcoin para calcular directamente el precio histórico de cada una de las monedas digitales (en unidades: dólares).

# 将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í, añadimos una nueva columna para cada pieza de datos de una moneda para almacenar su precio en dólares correspondiente.

Luego, podemos volver a usar la función definida anteriormente, merge_dfs_on_column, para crear una pila de datos combinada que integre los precios en dólares de cada moneda digital.

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

¡Todo bien!

Ahora vamos a añadir el precio de Bitcoin como el último bloque en el conjunto de datos fusionado.

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

Ahora tenemos el único conjunto de datos que contiene los precios diarios en dólares de las diez monedas digitales que estamos verificando.

Volvemos a llamar a la funcióndf_scatter anterior para mostrar los precios correspondientes de todas las monedas en forma de gráfico.

Este gráfico nos da una visión general de cómo han cambiado los precios de cada moneda digital en los últimos años.

Nota: Aquí usamos el eje y de las especificaciones de los logaritmos para comparar todas las monedas digitales en el mismo gráfico. También puede probar otros valores de parámetros diferentes (por ejemplo, escala = cuadrícula lineal) para entender los datos desde diferentes perspectivas.

3.4 Comienza el análisis de correlación

Un lector atento puede haber notado que los precios de las monedas digitales parecen estar relacionados, a pesar de la gran diferencia de valor de sus monedas y de su alta volatilidad. Especialmente desde la explosiva subida de abril de 2017, incluso muchas pequeñas fluctuaciones parecen estar sincronizadas con las fluctuaciones del mercado en general.

Por supuesto, las conclusiones basadas en datos son más convincentes que las intuiciones basadas en imágenes.

Podemos usar la función de correlación de Pandas para verificar la hipótesis de correlación anterior. Esta prueba calcula los coeficientes de correlación de Pearson para cada pieza de la pila de datos que corresponde a la otra pieza.

2017.8.22 Modificación: Esta parte ha sido modificada para utilizar el valor absoluto de la tasa de rendimiento diaria en lugar del precio en el cálculo de los factores relacionados.

El cálculo directo basado en una secuencia de tiempo no sólida (por ejemplo, datos de precios primitivos) puede causar una desviación de los coeficientes de correlación. Para este problema, nuestra solución es usar el método pct_change (), que convierte el valor absoluto de cada precio en la pila de datos en la correspondiente tasa de retorno diaria.

Por ejemplo, vamos a calcular los coeficientes correlativos para 2016.

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

Nombre	El DASH	C.T.C. y demás	ETH	TLC	SC	El número de registro	XEM	XMR	El XRP	El valor de las acciones
El DASH	1.000000	0.003992	0.122695	-0.012194	0.026602	0.058083	0.014571	0.121537	0.088657	-0.014040
C.T.C. y demás	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
TLC	-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
El número de registro	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
El XRP	0.088657	-0.054095	0.085630	0.053712	0.021098	0.320116	0.101326	0.027649	1.000000	0.044161
El valor de las acciones	-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 todos los coeficientes correlacionados. Los coeficientes cercanos a 1 o -1, respectivamente, significan que la secuencia está positivamente correlacionada o inversamente correlacionada, y los coeficientes correlacionados cercanos a 0 indican que los objetos respectivos no están relacionados y que sus fluctuaciones son independientes entre sí.

Para obtener mejores resultados de visualización, hemos creado una nueva función de ayuda 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 en rojo oscuro representan una fuerte correlación (cada moneda está claramente relacionada con su propia altitud) y los valores en azul oscuro representan una correlación inversa. Todos los colores intermedios -azul claro/rosa/gris/marrón- representan valores con diferentes grados de poca correlación o no correlación.

¿Qué nos dice este gráfico? Básicamente, muestra la fluctuación de los precios de las diferentes monedas digitales durante el año 2016 con poca correlación estadísticamente significativa.

Ahora, para verificar nuestra hipótesis de que las monedas digitales aumentan su relevancia en los últimos meses, vamos a repetir la misma prueba con datos que comienzan en 2017.

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

Nombre	El DASH	C.T.C. y demás	ETH	TLC	SC	El número de registro	XEM	XMR	El XRP	El valor de las acciones
El DASH	1.000000	0.384109	0.480453	0.259616	0.191801	0.159330	0.299948	0.503832	0.066408	0.357970
C.T.C. y demás	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
TLC	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
El número de registro	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
El XRP	0.066408	0.053955	0.120227	0.321340	0.248389	0.621547	0.270390	0.213608	1.000000	0.170070
El valor de las acciones	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? ¿Son suficientes para ser un criterio de evaluación de la inversión?

Sin embargo, es importante destacar que casi todas las monedas digitales se han vuelto cada vez más interconectadas.

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

Como se puede ver en el gráfico, las cosas se están poniendo más interesantes.

¿Por qué ocurre esto?

¡Es una buena pregunta! Pero la verdad es que no estoy muy seguro...

Mi primera reacción fue que los hedge funds recientemente comenzaron a operar públicamente en el mercado de divisas. Estos fondos tienen mucho más capital que los operadores normales, y si un fondo se arriesga a su capital de inversión en varias divisas digitales, entonces usa una estrategia de negociación similar para cada una de las divisas según las variables independientes (por ejemplo, el mercado de valores).

Comprender mejor XRP y STR

Por ejemplo, se puede ver claramente en el gráfico anterior que XRP (el token de Ripple) tiene la menor correlación con otras monedas digitales. Pero hay una excepción notable aquí: STR (el token de Stellar, cuyo nombre oficial es "Lumens"), tiene una fuerte correlación con XRP (coeficiente de correlación: 0.62).

Curiosamente, Stellar y Ripple son plataformas de Fintech muy similares, y ambas están diseñadas para reducir los pasos onerosos en las transferencias transnacionales entre bancos. Curiosamente, teniendo en cuenta la similitud de los servicios de blockchain que utilizan tokens, algunos grandes jugadores y fondos de cobertura podrían usar estrategias comerciales similares para sus inversiones en Stellar y Ripple.

¡Bueno, ahora es tu turno!

Las explicaciones anteriores son en gran parte especulativas, y tal vez sea mejor que lo hagas. Sobre la base de lo que hemos establecido, hay cientos y miles de maneras diferentes de continuar explorando las historias ocultas en los datos.

Aquí hay algunas sugerencias que los lectores pueden hacer para avanzar en estas direcciones:

• Se agregaron más datos de monedas digitales para el análisis completo
• Ajustar el rango de tiempo y la granularidad del análisis de correlación para obtener una vista de tendencia optimizada o de granularidad gruesa.
• Busca tendencias desde el volumen de transacciones o la minería de datos de la cadena de bloques. En comparación con los datos de precios originales, si quieres predecir las fluctuaciones de precios futuros, es posible que necesites más datos de la proporción de compras/vendidas.
• Añadir datos de precios en acciones, productos y monedas legales para determinar cuál de ellos está relacionado con la moneda digital.
• Utiliza el Registro de Eventos, GDELT y GoogleTrends para cuantificar el número de columnas de palabras candentes en torno a una determinada moneda digital.
• Utiliza los datos para entrenar un modelo de aprendizaje automático predictivo para predecir los precios de mañana. Si tienes una mayor ambición, incluso puedes considerar probar el entrenamiento anterior con redes neuronales circulares (RNN).
• Utilice sus análisis para crear un robot de negociación automatizado, a través de una interfaz de programación de aplicaciones (API) correspondiente, que se aplica en sitios web de intercambios como Polonix o Coinbase. Tenga cuidado: un robot de bajo rendimiento puede fácilmente hacer que sus activos desaparezcan instantáneamente.这里推荐使用发明者量化平台FMZ.COM。

La mejor parte de Bitcoin, y de las monedas digitales en general, es su naturaleza descentralizada, lo que las hace más libres y democráticas que cualquier otro activo. Puedes compartir tu análisis en código abierto, participar en la comunidad, o escribir un blog. Espero que ahora tengas las habilidades necesarias para analizarte a ti mismo y la capacidad de pensar diacríticamente cuando leas en el futuro cualquier artículo sobre monedas digitales especulativas, especialmente aquellas que no tengan predicciones respaldadas por datos.https://www.fmz.com/bbsEn la página de Facebook de @Mohammed_Khalil

Relacionados

Más.