Um método de análise especulativa de moeda digital baseado em dados

Como é que o preço do Bitcoin se comporta? Quais são as razões para o aumento e queda do preço da moeda digital? Os preços de mercado das diferentes moedas estão inseparavelmente ligados ou são em grande parte independentes?

Os artigos sobre moedas digitais, como Bitcoin e Ethereum, estão agora repletos de especulações, com centenas de pessoas que se autodenominam especialistas defendendo as tendências que esperam que surjam. Muitas dessas análises não possuem uma base sólida de dados básicos e modelos estatísticos.

O objetivo deste artigo é fornecer uma breve introdução à análise de moedas digitais usando o Python. Vamos buscar, analisar e visualizar dados de diferentes moedas digitais através de um simples script Python. Ao longo do processo, vamos descobrir esses comportamentos de mercado flutuantes e tendências interessantes sobre como eles evoluem.

Este não é um artigo para explicar a moeda digital, nem uma visão sobre quais moedas específicas vão subir e quais vão cair. Em vez disso, o que estamos focando neste tutorial é apenas obter dados brutos e descobrir histórias escondidas nos números.

Primeiro passo: construir o nosso ambiente de trabalho com dados.

Este tutorial é destinado a amadores, engenheiros e cientistas de dados de todos os níveis de habilidade. Se você é um robô da indústria ou um novato em programação, a única habilidade que você precisa é um conhecimento básico da linguagem de programação Python e conhecimento suficiente das operações da linha de comando (para montar um projeto de ciência de dados).

1.1 Instalar o Inventor Quantify Host e configurar o Anaconda

• Sistema de administradores quantificados pelo inventor

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

Todos os recursos mencionados acima estão embutidos em um sistema semelhante ao Docker, o que precisamos fazer é comprar ou alugar o nosso próprio serviço de nuvem e implementar o sistema Docker.

No nome oficial da plataforma de quantificação dos inventores, o sistema Docker é conhecido como sistema administrador.

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

Os leitores que desejam comprar um administrador de instalação de servidores de nuvem podem consultar este artigo:https://www.fmz.com/bbs-topic/2848

Depois de implementarmos com sucesso um bom sistema de serviços e administradores de nuvem, vamos instalar o maior templo do Python até agora: o Anaconda.

Para implementar todos os ambientes de programação necessários para este artigo (dependências, gerenciamento de versões, etc.), o método mais simples é usar o Anaconda. É um ecossistema de ciência de dados Python e um gerenciador de dependências.

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

Para saber como instalar o Anaconda, consulte o guia oficial do Anaconda:https://www.anaconda.com/distribution/

Se você é um programador Python experiente e sente que não precisa usar o Anaconda, não há problema nenhum. Eu vou assumir que você não precisa de ajuda para instalar dependências necessárias, você pode saltar para a segunda parte.

1.2 Criar um ambiente de projeto de análise de dados com Anaconda

Depois de instalar o Anaconda, precisamos criar um novo ambiente para gerenciar nossos pacotes de dependências.

conda create --name cryptocurrency-analysis python=3

A partir daí, a empresa criou um novo ambiente para o Anaconda para o projeto.

Em seguida, digite

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

Para ativar esse ambiente.

Em seguida, digite:

conda install numpy pandas nb_conda jupyter plotly

Os pacotes de dependência necessários para instalar o projeto.

Nota: Por que usar um ambiente Anaconda? Se você pretende executar muitos projetos Python em seu computador, é útil separar os pacotes de dependências de diferentes projetos (repertório e pacotes) para evitar conflitos.

1.3 Criar um notebook do Jupyter

Quando o ambiente e os pacotes de dependência estiverem instalados, é possível executar

jupyter notebook

Para iniciar o núcleo do Python, acesse http://localhost:8888/Para criar um novo notebook Python, certifique-se de que ele usa:

Python [conda env:cryptocurrency-analysis]

Núcleo

1.4 Importação de pacotes de dependências

Construímos um novo notebook Jupiter vazio e a primeira coisa que fazemos é 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 de importar Plotly e ativar 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)

Segundo passo: obter informações sobre o preço da moeda digital

O trabalho de preparação está concluído e agora podemos começar a obter os dados a serem analisados.

Isso vai usar a função GetTicker, para mais detalhes sobre como usar essas duas funções, veja:https://www.fmz.com/api

2.1 Escrever funções de coleta de dados do Quandl

Para facilitar a obtenção de dados, nós temos que escrever uma função para baixar e sincronizar a partir do Quandl ().quandl.comO Quandl é uma plataforma de quantificação de inventores que também oferece uma interface de dados semelhante, principalmente para uso em negociações em tempo real. Como este artigo é sobre análise de dados, aqui usamos dados do Quandl.

Quando se trata de negociação em disco real, as funções GetTicker e GetRecords podem ser chamadas diretamente no Python para obter dados de preços.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

Aqui, o pickle é usado para ordenar os dados e guardar os dados baixados em um arquivo, de modo que o programa não descarregue os mesmos dados de novo a cada execução. Esta função retornará dados no formato de Dataframe do Panda.

2.2 Obter dados de preços de moedas digitais da Kraken Exchange

Vamos usar o Kraken Bitcoin Exchange como exemplo, começando pelo preço do Bitcoin que ele recebeu.

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

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

btc_usd_price_kraken.head()

O resultado foi:

BTC	Aberto	Alto	Baixo	Fechado	Volume (BTC)	Volume (moeda)	Preço 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

O próximo passo é fazer uma tabela simples para verificar a exatidão dos dados através de métodos visuais.

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

Dica: os gráficos gerados podem ser comparados com os gráficos de preços de Bitcoin de exchanges tradicionais (como os gráficos no OKEX, Binance ou Huobi) como um rápido cheque de integridade para confirmar se os dados baixados são basicamente iguais.

2.3 Obter dados de preços das principais exchanges de Bitcoin

Os leitores atentos podem ter percebido que há uma falta de dados nos dados acima, especialmente no final de 2014 e início de 2016.

As trocas de moeda digital são caracterizadas pela relação de oferta e demanda que determina o preço das moedas. Portanto, nenhum preço de transação pode ser o preço dominante do mercado. Para resolver esse problema, e o problema da falta de dados mencionado anteriormente (possivelmente devido a falhas técnicas e erros nos dados), vamos baixar dados dos três principais mercados de bitcoin do mundo e calcular o preço médio do bitcoin.

Para começar, vamos baixar os dados de cada uma das bolsas para um conjunto de dados composto por tipos 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 uma pilha de dados

No próximo passo, vamos definir uma função especial para juntar colunas compartilhadas em cada coluna de dados em uma nova coluna de dados.

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, baseando-se nos preços de potência agregada de cada conjunto de dados, todos os bits de dados são integrados.

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

Por fim, usamos o método do "tail" para verificar as últimas cinco linhas de dados após a combinação para garantir que os dados estejam corretos e completos.

btc_usd_datasets.tail()

Os resultados mostram:

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 no gráfico acima, os dados estão de acordo com nossas expectativas, com a mesma gama de dados, apenas com ligeiras diferenças com base em atrasos ou características individuais de cada bolsa.

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

Do ponto de vista da lógica analítica, o próximo passo é comparar esses dados através da visualização. Para isso, precisamos primeiro de definir uma função auxiliar, que é chamada de funçãodf_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 a compreensão, este artigo não explora muito o princípio lógico desta função auxiliar. Para mais informações, consulte os documentos oficiais de instruções de Pandas e Plotly.

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

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

2.6 Limpar e adicionar dados de preço total

Como pode ser visto no gráfico acima, embora as quatro séries de dados sigam o mesmo caminho, ainda há algumas variações irregulares, que tentaremos eliminar.

Durante o período de 2012-2017, sabemos que o preço do Bitcoin nunca foi igual a zero, então primeiro removemos todos os zeros da caixa de dados.

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

Após a reconstrução da pilha de dados, podemos ver gráficos mais claros, sem falta de dados.

# 绘制修订后的数据框
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 exchanges.

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

A nova coluna é o índice de preço do Bitcoin! Vamos desenhá-lo novamente para verificar se há algum problema com o que parece ser o dado.

# 绘制平均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 mais tarde, continuaremos a usar esse conjunto de dados de sequência de preços para determinar a taxa de conversão entre outras moedas digitais e dólares.

O terceiro passo: coletar o preço das altcoins.

Até agora, temos dados de sequência de tempo do preço do Bitcoin. Em seguida, vamos olhar para alguns dados de moedas digitais não-Bitcoin, que são as altcoins, é claro, o termo altcoin pode ser um pouco exagerado, mas no que diz respeito ao estado atual das moedas digitais, exceto os dez maiores de valor de mercado (como Bitcoin, Ethereum, EOS, USDT, etc.), a maioria pode ser considerada uma moeda não é um problema, devemos nos afastar o máximo possível dessas moedas quando negociamos, pois são muito confusas e enganosas.

3.1 Funções auxiliares definidas através da API da Poloniex

Primeiro, usamos a API da Poloniex para obter informações de transações de moeda digital. Definimos duas funções auxiliares para obter dados relacionados com a criptomoeda, que são principalmente para baixar e armazenar dados JSON através da API.

Primeiro, definimos a função get_json_data, que irá baixar e armazenar dados JSON a partir de um determinado 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 irá gerar uma solicitação HTTP da API Poloniex e chamar a função get_json_data que acabamos de definir para salvar os resultados das chamadas.

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 extrai o código de caracteres do par de moedas digitais (por exemplo, o par BTC_ETH) e retorna o par de dados que contém os preços históricos de duas moedas.

3.2 Baixar dados de preços de transações do Poloniex

A maioria das criptomoedas não pode ser comprada diretamente com dólares, e os indivíduos geralmente precisam comprar bitcoins para obter essas criptomoedas e trocá-las por criptomoedas de acordo com a proporção de preços entre elas. Portanto, temos que baixar a taxa de câmbio de cada criptomoeda para trocar bitcoins e depois convertê-los em dólares usando os dados de preços de bitcoins 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

Agora, temos um dicionário com nove blocos de dados, cada um contendo dados sobre o preço médio histórico diário entre a moeda digital e o Bitcoin.

Podemos determinar se os dados estão corretos através das últimas linhas da tabela de preços do Ethereum.

altcoin_data['ETH'].tail()

ETH	Aberto	Alto	Baixo	Fechado	Volume (BTC)	Volume (moeda)	Preço 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 as informações de preços em dólares

Agora, podemos combinar os dados de câmbio de BTC com o nosso índice de preço do Bitcoin para calcular diretamente o preço histórico de cada moeda (unidade: 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']

Aqui, adicionamos uma nova coluna para o banco de dados de cada moeda para armazenar seu preço em dólares correspondente.

Em seguida, podemos reutilizar a função merge_dfs_on_column, definida anteriormente, para criar uma pilha de dados combinada que integra os preços em dólares de cada moeda digital.

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

Está bem!

Agora, vamos adicionar o preço do Bitcoin ao conjunto de dados após a fusão como o último bloco.

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

Agora temos um único banco de dados que contém os preços diários em dólares das dez moedas digitais que estamos verificando.

Nós re-chamamos a função anteriordf_scatter para mostrar o preço correspondente de todas as moedas em forma de gráfico.

O gráfico não parece ser um problema, e este gráfico nos dá uma visão geral da mudança de preços de cada moeda digital nos últimos anos.

Observação: aqui usamos o eixo y das especificações do logaritmo para comparar todas as moedas digitais no mesmo gráfico. Você também pode experimentar outros valores de parâmetros diferentes (por exemplo, escala = quadrado linear) para entender os dados de diferentes perspectivas.

3.4 Iniciar a análise de correlação

O leitor atento pode ter notado que os preços das moedas digitais parecem estar relacionados, apesar da grande diferença de valor entre as moedas e da alta volatilidade. Especialmente a partir do aumento acelerado em abril de 2017, muitas das pequenas oscilações parecem estar sincronizadas com as flutuações do mercado em geral.

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

A função Panda corr () pode ser usada para verificar a hipótese de correlação acima. Este teste calcula o coeficiente de correlação de Pearson para cada um dos eixos de dados correspondentes ao outro eixo.

2017.8.22 Nota de revisão: esta parte foi modificada para usar o valor absoluto do preço em vez do valor da taxa de retorno diária no cálculo dos coeficientes relacionados.

O cálculo direto baseado em uma sequência de tempo não-solidos (por exemplo, dados de preços primários) pode resultar em desvios nos coeficientes de correlação. Para este problema, a nossa solução é usar o método pct_change, que converte o valor absoluto de cada preço no conjunto de dados em uma correspondente taxa de retorno diário.

Por exemplo, vamos calcular os coeficientes correspondentes em 2016.

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

Nome	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 todos os coeficientes correlacionados. Coeficientes próximos de 1 ou 1, respectivamente, significam que a sequência é positivamente correlacionada ou inversamente correlacionada, e coeficientes correlacionados próximos de 0 indicam que os respectivos objetos não estão relacionados e que suas flutuações são independentes umas das outras.

Para obter melhores resultados de visualização, criamos uma nova função de ajuda 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 em vermelho escuro representam uma forte correlação (cada moeda é claramente relacionada à sua própria altitude) e os valores em azul escuro representam uma correlação inversa. Todas as cores intermediárias - azul claro/laranja/cinza/marrom - representam diferentes graus de fraca correlação ou não correlação.

Basicamente, ele mostra a variação de preços de diferentes moedas digitais em 2016, com pouca correlação estatisticamente significativa.

Agora, para verificar a nossa hipótese de que as moedas digitais aumentaram de relevância nos últimos meses, vamos repetir 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')

Nome	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

Os dados acima são mais relevantes? São suficientes como critérios de julgamento para o investimento?

No entanto, é interessante notar que quase todas as moedas digitais estão cada vez mais interligadas.

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

Como você pode ver no gráfico acima, as coisas estão ficando mais e mais interessantes.

Por que isso acontece?

Mas a verdade é que eu não tenho a certeza...

Minha primeira reação foi que os hedge funds começaram recentemente a negociar publicamente no mercado de moedas digitais. Esses fundos possuem muito mais capital do que os traders comuns, e se um fundo hedge seu capital de investimento entre várias moedas digitais, então usa estratégias de negociação semelhantes para cada moeda de acordo com variáveis independentes (por exemplo, o mercado de ações).

Compreender melhor o XRP e o STR

Por exemplo, no gráfico acima, pode-se ver claramente que o XRP (o token da Ripple) tem a menor relação com outras moedas digitais. Mas há uma exceção notável: o STR (o token da Stellar, com o nome oficial de "Lumens"), tem uma forte relação com o XRP (coeficiente de correlação: 0.62).

Curiosamente, Stellar e Ripple são plataformas de tecnologia financeira muito semelhantes, ambas com o objetivo de reduzir os passos onerosos em transferências transnacionais entre bancos. Curiosamente, considerando a semelhança entre os serviços blockchain e o uso de tokens, alguns grandes jogadores e fundos de hedge podem usar estratégias de negociação semelhantes para seus investimentos no Stellar e no Ripple.

Está bem, é a tua vez!

As explicações acima são, em grande parte, especulativas, e talvez você faça melhor. Com base no que já estabelecemos, há centenas e milhares de maneiras diferentes de continuar explorando as histórias escondidas nos dados.

Aqui estão algumas das minhas sugestões para que o leitor possa seguir em frente:

• Adicionar mais dados de moedas digitais para a análise completa
• Ajustar o intervalo de tempo e a granulação da análise de correlação para obter uma visão de tendência otimizada ou com granulação grosseira.
• Buscar tendências a partir de volumes de transações ou de dados de mineração de blocos. Em comparação com dados de preços primários, você pode precisar de dados de proporções de compra/venda se quiser prever as flutuações de preços futuras.
• Adicionar dados de preços em ações, mercadorias e moedas legais para determinar qual delas é relevante para a moeda digital (mas, não se esqueça do ditado de que não há correlação causal)
• Use o Registro de Eventos, GDELT e GoogleTrends para quantificar o número de hashtags em torno de uma determinada moeda digital.
• Use os dados para treinar um modelo de aprendizado de máquina preditivo para prever os preços de amanhã. Se você tiver ambições maiores, você pode até considerar experimentar o treinamento acima com redes neurais circulares (RNN).
• Use suas análises para criar um robô de negociação automatizado, através de uma interface de programação de aplicativos (API), aplicada em sites de exchanges como o Bitcoin Poloniiex ou o Bitcoin Coinbase.这里推荐使用发明者量化平台FMZ.COM。

A melhor parte sobre o Bitcoin, e sobre a moeda digital em geral, é a sua natureza descentralizada, o que o torna mais livre e democrático do que qualquer outro ativo. Você pode compartilhar sua análise de código aberto, participar da comunidade ou escrever um blog!https://www.fmz.com/bbsO blogueiro também escreveu sobre o assunto.

Relacionados

Mais.