Uma abordagem baseada em dados para analisar a especulação em moeda digital

Como está o desempenho do preço do Bitcoin? O que faz com que os preços das criptomoedas disparem e despenquem? Os preços de mercado de diferentes altcoins estão inextricavelmente ligados ou são amplamente independentes? Como podemos prever o que vai acontecer a seguir?

Artigos sobre moedas digitais, como Bitcoin e Ethereum, agora estão cheios de especulações, com centenas de autoproclamados especialistas defendendo tendências que esperam que surjam. O que falta em muitas dessas análises é uma base sólida em dados subjacentes e modelos estatísticos.

O objetivo deste artigo é fornecer uma introdução simples à análise de criptomoedas usando Python. Analisaremos um script Python simples para recuperar, analisar e visualizar dados de diferentes criptomoedas. Ao longo do caminho, descobriremos tendências interessantes no comportamento desses mercados voláteis e como eles se desenvolvem.

Este não é um artigo explicando criptomoedas, nem é um artigo de opinião sobre quais moedas específicas subirão e quais cairão. Em vez disso, nosso foco neste tutorial é simplesmente pegar os dados brutos e descobrir as histórias escondidas nos números.

Etapa 1: construir nosso ambiente de trabalho de dados

Este tutorial foi criado para entusiastas, engenheiros e cientistas de dados de todos os níveis de habilidade. Seja você um especialista da indústria ou um novato em programação, as únicas habilidades necessárias são um entendimento básico da linguagem de programação Python e conhecimento suficiente de operações de linha de comando. (Basta ser capaz de configurar um projeto de ciência de dados).

1.1 Instale o Inventor Quant Host e configure o Anaconda

• Inventor do Sistema de Custódia Quantificada

Além de fornecer fontes de dados de alta qualidade das principais bolsas tradicionais, a Plataforma Quantitativa Inventor FMZ.COM também fornece um rico conjunto de interfaces de API para nos ajudar a realizar transações automatizadas após concluir a análise de dados. Este conjunto de interfaces inclui ferramentas práticas, como consulta de informações de conta, consulta de preços altos, de abertura, baixos e de fechamento, volume de negociação, vários indicadores de análise técnica comumente usados ​​em várias bolsas tradicionais, etc., especialmente para conexão com as principais bolsas tradicionais na prática. processos de negociação. A interface API pública fornece suporte técnico poderoso.

Todas as funções mencionadas acima são encapsuladas em um sistema similar ao Docker. Tudo o que temos que fazer é comprar ou alugar nosso próprio serviço de computação em nuvem e então implantar o sistema Docker.

No nome oficial da Inventor Quantitative Platform, esse sistema Docker é chamado de sistema host.

Para obter mais informações sobre como implantar hosts e robôs, consulte meu artigo anterior: https://www.fmz.com/bbs-topic/4140

Os leitores que desejam adquirir seu próprio host de implantação de servidor de computação em nuvem podem consultar este artigo: https://www.fmz.com/bbs-topic/2848

Após a implantação bem-sucedida do serviço de computação em nuvem e do sistema host, instalaremos a ferramenta Python mais poderosa: Anaconda

Para obter todos os ambientes de programa relevantes necessários para este artigo (bibliotecas dependentes, gerenciamento de versões, etc.), a maneira mais fácil é usar o Anaconda. É um ecossistema de ciência de dados Python empacotado e um gerenciador de dependências.

Como estamos instalando o Anaconda em um serviço de nuvem, recomendamos que você instale o sistema Linux mais a versão de linha de comando do Anaconda no servidor de nuvem.

Para o método de instalação do Anaconda, consulte o guia oficial do Anaconda: https://www.anaconda.com/distribution/

Se você é um programador Python experiente e não sente necessidade de usar o Anaconda, tudo bem. Presumo que você não precise de ajuda para instalar as dependências necessárias e pode pular para a Parte 2.

1.2 Crie um ambiente de projeto de análise de dados Anaconda

Após a instalação do Anaconda, precisamos criar um novo ambiente para gerenciar nossos pacotes de dependências. Na interface de linha de comando do Linux, inserimos:

conda create --name cryptocurrency-analysis python=3

Vamos criar um novo ambiente Anaconda para nosso projeto.

Em seguida, digite

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

Para ativar este ambiente

Em seguida, digite:

conda install numpy pandas nb_conda jupyter plotly

Para instalar os vários pacotes de dependência necessários para este projeto.

Nota: Por que usar o ambiente Anaconda? Se você planeja executar muitos projetos Python no seu computador, é útil separar as dependências (bibliotecas e pacotes) de diferentes projetos para evitar conflitos. O Ananconda cria um diretório de ambiente especial para cada pacote de dependência do projeto, para que todos os pacotes possam ser gerenciados e diferenciados adequadamente.

1.3 Crie um Jupyter Notebook

Após a instalação dos pacotes de ambiente e dependência, execute

jupyter notebook

para iniciar o kernel do iPython, aponte seu navegador para http://localhost:8888/ e crie um novo notebook Python, certificando-se de que ele usa:

Python [conda env:cryptocurrency-analysis]

Núcleo

1.4 Importando pacotes dependentes

Crie um novo notebook Jupyter vazio e a primeira coisa que precisamos fazer é importar os pacotes de dependência necessários.

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

Também precisamos importar o Plotly e habilitar o modo offline

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

Etapa 2: Obtenha informações sobre o preço da moeda digital

Agora que os preparativos estão completos, podemos começar a adquirir os dados a serem analisados. Primeiro, precisamos usar a interface da API da Plataforma Quantitativa do Inventor para obter dados de preço do Bitcoin.

Isso usará a função GetTicker. Para detalhes sobre o uso dessas duas funções, consulte: https://www.fmz.com/api

2.1 Escreva a função de coleta de dados Quandl

Para facilitar a aquisição de dados, precisamos escrever uma função para baixar e sincronizar dados do Quandl (quandl.com). Esta é uma interface de dados financeiros gratuita muito conhecida no exterior. A Inventor Quantitative Platform também fornece uma interface de dados similar, que é usada principalmente para negociação em tempo real. Como este artigo é principalmente para análise de dados, ainda usamos os dados da Quandl aqui.

Ao negociar em tempo real, você pode chamar diretamente as funções GetTicker e GetRecords em Python para obter dados de preço. Para seu 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

A biblioteca pickle é usada aqui para serializar os dados e salvar os dados baixados como um arquivo, para que o programa não baixe novamente os mesmos dados toda vez que for executado. Esta função retornará os dados no formato Pandas Dataframe. Se você não está familiarizado com o conceito de um quadro de dados, pense nele como uma planilha poderosa do Excel.

2.2 Obtendo dados de preços de criptomoedas da bolsa Kraken

Vamos usar a bolsa de Bitcoin Kraken como exemplo e começar obtendo seu preço de Bitcoin.

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

Use o método head() para visualizar as cinco primeiras linhas do quadro de dados.

btc_usd_price_kraken.head()

O resultado é:

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

Em seguida, precisamos criar uma tabela simples para verificar a exatidão dos dados por meio da visualização.

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

Aqui, usamos o Plotly para completar a parte de visualização. Plotly é uma escolha menos comum do que usar algumas das bibliotecas de visualização de dados Python mais maduras, como Matplotlib, mas é uma boa escolha porque pode chamar D3.js para gráficos totalmente interativos. Os gráficos têm configurações padrão muito boas, são fáceis de explorar e muito práticos para incorporar em páginas da web.

Dica: Você pode comparar o gráfico gerado com um gráfico de preços do Bitcoin de uma grande bolsa (como a da OKEX, Binance ou Huobi) como uma verificação rápida para confirmar se os dados baixados são aproximadamente consistentes.

2.3 Obtendo dados de preços das principais bolsas de Bitcoin

Leitores atentos podem ter notado que há dados ausentes nos dados acima, especialmente no final de 2014 e no início de 2016. Essa lacuna de dados é particularmente evidente na bolsa Kraken. Certamente não queremos que esses dados ausentes afetem nossa análise de preços.

A característica das trocas de moedas digitais é que o preço da moeda é determinado pela oferta e demanda. Portanto, nenhum preço de transação pode se tornar o “preço principal” do mercado. Para resolver esse problema, bem como o problema de dados ausentes mencionado anteriormente (possivelmente devido a interrupções técnicas e erros de dados), baixaremos dados das três principais bolsas de Bitcoin do mundo e calcularemos o preço médio do Bitcoin.

Vamos começar baixando os dados de cada troca em um dataframe que consiste em um tipo de dicionário.

# 下载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 os dados em um único quadro de dados

Em seguida, definiremos uma função especial para mesclar as colunas comuns de cada quadro de dados em um novo quadro de dados. Vamos chamá-la de função 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)

Agora, combine todos os dataframes com base na coluna “preço ponderado” de cada conjunto de dados.

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

Por fim, usamos o método “tail()” para visualizar as últimas cinco linhas dos dados mesclados para garantir que os dados estejam corretos e completos.

btc_usd_datasets.tail()

O resultado é:

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 você pode ver na tabela acima, esses dados estão em linha com nossas expectativas. O intervalo de dados é aproximadamente o mesmo, mas há pequenas diferenças com base na latência ou nas características de cada exchange.

2.5 Processo de visualização de dados de preços

Da perspectiva da lógica analítica, o próximo passo é comparar esses dados por meio da visualização. Para fazer isso, precisamos primeiro definir uma função auxiliar que use os dados para fazer um gráfico fornecendo um comando de linha única. Vamos chamá-la de função 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 facilitar sua compreensão, este artigo não discutirá o princípio lógico desta função auxiliar em detalhes. Se quiser saber mais, confira a documentação oficial do Pandas e do Plotly.

Agora podemos criar facilmente gráficos de dados de preços do Bitcoin!

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

2.6 Dados de preços limpos e agregados

Como você pode ver no gráfico acima, embora as quatro séries sigam aproximadamente o mesmo caminho, há algumas irregularidades nelas, que tentaremos esclarecer.

No período de 2012-2017, sabemos que o preço do Bitcoin nunca foi igual a zero, então primeiro removemos todos os valores zero no quadro de dados.

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

Depois de reconstruir o dataframe, podemos ver um gráfico muito mais claro, sem dados ausentes.

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

Agora podemos calcular uma nova coluna: o preço médio diário do Bitcoin em todas as bolsas.

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

A nova coluna é o índice de preços do Bitcoin! Vamos plotar novamente para verificar se há algo errado com os dados.

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

Parece que não há problema, e continuaremos a usar esses dados agregados de séries de preços mais tarde para poder determinar a taxa de câmbio entre outras criptomoedas e o dólar americano.

Etapa 3: coletar os preços das altcoins

Até agora, temos dados de séries temporais para preços do Bitcoin. A seguir, vamos dar uma olhada em alguns dados sobre moedas digitais não Bitcoin, ou seja, a situação das altcoins. Claro, o termo altcoin pode ser um pouco forte demais, mas quanto ao desenvolvimento atual das moedas digitais, além do ranking de capitalização de mercado A maioria das dez principais (como Bitcoin, Ethereum, EOS, USDT, etc.) podem ser chamadas de altcoins. Não há problema. Devemos tentar ficar longe dessas moedas ao negociar porque elas são muito confusas e enganosas. alto.

3.1 Definindo funções auxiliares através da API de troca Poloniex

Primeiro, usamos a API da bolsa Poloniex para obter informações de dados sobre transações de moeda digital. Definimos duas funções auxiliares para obter os dados relevantes de altcoins. Essas duas funções principalmente baixam e armazenam em cache dados JSON por meio da API.

Primeiro, definimos a função get_json_data, que baixará e armazenará em cache dados JSON de uma determinada URL.

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

Em seguida, definimos uma nova função que fará uma solicitação HTTP para a API Poloniex e chamará a função get_json_data que acabamos de definir para salvar o resultado da chamada.

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

A função acima extrairá o código de string do par de criptomoedas (como “BTC_ETH”) e retornará um quadro de dados contendo os preços históricos de ambas as moedas.

3.2 Baixando dados de preços de transações da Poloniex

A maioria das altcoins não pode ser comprada diretamente usando dólares americanos. Se os indivíduos quiserem obter essas moedas digitais, eles geralmente precisam comprar Bitcoin primeiro e depois trocá-los por altcoins com base na relação de preço entre eles. Portanto, temos que baixar a taxa de câmbio de cada moeda digital para Bitcoin e, então, usar os dados de preço do Bitcoin existentes para converter para dólares americanos. Baixaremos dados de transações para as 9 principais criptomoedas: Ethereum, Litecoin, Ripple, EthereumClassic, Stellar, Dash, Siacoin, Monero e 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

Agora temos um dicionário contendo 9 quadros de dados, cada um contendo dados históricos de preços médios diários entre altcoins e Bitcoin.

Podemos determinar se os dados estão corretos observando as últimas linhas da tabela de preços do 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 os dados de preços devem ser expressos em dólares americanos

Agora podemos combinar dados de taxa de câmbio de BTC para altcoin com nosso Índice de Preços de Bitcoin para calcular diretamente o preço histórico de cada altcoin em 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']

Aqui, adicionamos uma nova coluna ao dataframe para cada altcoin para armazenar seu preço correspondente em USD.

Em seguida, podemos reutilizar a função merge_dfs_on_column que definimos anteriormente para criar um dataframe mesclado que integra o preço em USD de cada criptomoeda.

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

Feito!

Agora vamos também adicionar o preço do Bitcoin como a última coluna do dataframe mesclado.

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

Agora temos um dataframe exclusivo que contém os preços diários em USD para as dez criptomoedas que estamos validando.

Chamamos a função anterior df_scatter novamente para exibir os preços correspondentes de todas as altcoins na forma de um gráfico.

O gráfico parece bom e nos dá uma imagem completa de como o preço de câmbio de cada criptomoeda mudou nos últimos anos.

Nota: Aqui usamos um eixo y logarítmico para comparar todas as criptomoedas no mesmo gráfico. Você também pode tentar diferentes valores de parâmetros (como scale=‘linear’) para entender os dados de diferentes perspectivas.

3.4 Iniciar análise de correlação

Leitores atentos podem ter notado que os preços das moedas digitais parecem estar correlacionados, embora seus valores monetários variem muito e sejam altamente voláteis. Principalmente desde o rápido aumento em abril de 2017, até mesmo muitas pequenas flutuações parecem ocorrer em sincronia com as flutuações de todo o mercado.

É claro que conclusões apoiadas por dados são mais convincentes do que intuições baseadas em imagens.

Podemos usar a função Pandas corr() para verificar a hipótese de correlação acima. Este teste calcula o coeficiente de correlação de Pearson para cada coluna do quadro de dados com todas as outras colunas.

Nota de revisão de 22/08/2017: Esta seção foi modificada para usar retornos diários em vez de preços absolutos ao calcular coeficientes de correlação.

O cálculo direto com base em séries temporais não sólidas (como dados de preços brutos) pode levar a desvios no coeficiente de correlação. Nossa solução para esse problema é usar o método pct_change() para converter o valor absoluto de cada preço no quadro de dados na taxa de retorno diária correspondente.

Por exemplo, vamos calcular o coeficiente de correlação 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

O gráfico acima mostra os coeficientes de correlação. Um coeficiente próximo de 1 ou -1 significa que a sequência é positivamente correlacionada ou inversamente correlacionada, respectivamente. Um coeficiente de correlação próximo de 0 significa que os objetos correspondentes não são correlacionados e suas flutuações são independentes umas das outras.

Para visualizar melhor os resultados, criamos uma nova função auxiliar de visualização.

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

Aqui, os valores vermelho-escuros representam forte correlação (cada moeda é obviamente altamente correlacionada consigo mesma) e os valores azul-escuros representam correlação inversa. Todas as cores intermediárias — azul claro/laranja/cinza/marrom — têm valores que representam vários graus de correlação fraca ou nenhuma correlação.

O que essa imagem nos diz? Em um nível básico, ele mostra como os preços de diferentes criptomoedas flutuaram ao longo de 2016, com pouca correlação estatisticamente significativa.

Agora, para verificar nossa hipótese de que “as criptomoedas se tornaram mais correlacionadas nos últimos meses”, repetiremos o mesmo teste usando dados 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

Esses dados são mais relevantes? É suficiente para servir como critério de investimento? A resposta é não.

Vale a pena notar, no entanto, que quase todas as criptomoedas se tornaram cada vez mais interconectadas.

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

Como você pode ver na imagem acima, as coisas estão ficando cada vez mais interessantes.

Por que isso acontece?

Boa pergunta! Mas a verdade é que não tenho tanta certeza…

Minha primeira reação foi que os fundos de hedge tinham começado recentemente a negociar publicamente nos mercados de criptomoedas. Esses fundos detêm muito mais capital do que o trader médio. Se um fundo protege seu capital de investimento entre múltiplas criptomoedas e então usa fatores de risco similares para cada moeda com base em uma variável independente (por exemplo, o mercado de ações), ele será mais lucrativo. Trading estratégias. Se vista dessa perspectiva, a tendência de aumento da correlação faz sentido.

Uma compreensão mais profunda do XRP e STR

Por exemplo, no gráfico acima, fica claro que o XRP (token da Ripple) é o menos correlacionado com outras criptomoedas. Mas uma exceção notável aqui é o STR (token da Stellar, oficialmente chamado de “Lumens”), que tem uma forte correlação com o XRP (coeficiente de correlação: 0,62).

Curiosamente, Stellar e Ripple são plataformas fintech muito semelhantes e ambas visam reduzir as etapas complicadas envolvidas na transferência de dinheiro entre bancos através de fronteiras. É possível que alguns grandes players e fundos de hedge usem estratégias de negociação semelhantes para seus investimentos em Stellar e Ripple, dada a similaridade dos tokens usados ​​pelos serviços de blockchain. Pode ser por isso que o XRP tem uma correlação mais forte com o STR do que outras criptomoedas.

Ok, é a sua vez!

As explicações acima são em grande parte especulativas, e talvez você consiga fazer melhor. Com base na base que criamos, há centenas de maneiras diferentes de continuar explorando as histórias em seus dados.

Aqui estão algumas das minhas sugestões para os leitores considerarem em suas direções de pesquisa:

• Adicionar dados sobre mais criptomoedas à análise geral
• Ajuste o intervalo de tempo e a granularidade da análise de correlação para obter visualizações refinadas ou mais detalhadas das tendências.
• Encontre tendências em volume de transações ou mineração de dados de blockchain. Se você quiser prever futuras flutuações de preços, talvez precise de dados de relação de volume de compra/venda mais do que de dados de preço bruto.
• Adicione dados de preços sobre ações, commodities e moedas fiduciárias para determinar quais delas estão correlacionadas com criptomoedas (mas lembre-se do velho ditado “correlação não implica causalidade”)
• Use o Event Registry, o GDELT e o Google Trends para quantificar o número de “palavras quentes” em torno de uma criptomoeda específica.
• Use os dados para treinar um modelo de aprendizado de máquina preditivo para prever o preço de amanhã. Se você estiver se sentindo mais ambicioso, você pode até considerar tentar fazer o treinamento acima com uma Rede Neural Recorrente (RNN).
• Use sua análise para criar um bot de negociação automatizado que pode ser usado em sites de câmbio como “Poloniex” ou “Coinbase” por meio da interface de programação de aplicativos (API) correspondente. Tenha cuidado: um bot com baixo desempenho pode facilmente destruir seus ativos em um instante. É recomendável usar a plataforma quantitativa do inventor FMZ.COM.

A melhor parte do Bitcoin, e das moedas digitais em geral, é sua natureza descentralizada, o que o torna mais livre e democrático do que qualquer outro ativo. Compartilhe sua análise como código aberto, envolva-se na comunidade ou escreva uma postagem de blog! Espero que agora você tenha as habilidades necessárias para conduzir sua própria análise e ser capaz de pensar criticamente sobre quaisquer artigos especulativos sobre criptomoedas que ler no futuro, especialmente aquelas previsões que não são apoiadas por dados. Obrigado por ler. Se você tiver algum comentário, sugestão ou crítica sobre este tutorial, deixe uma mensagem em https://www.fmz.com/bbs.