Os 4 gráficos essenciais para análise de criptomoedas
Conjunto de Dados
A. Importando as bibliotecas necessárias
Para começar, iniciaremos carregando as bibliotecas utilizadas para a obtenção dos dados e elaboração dos gráficos.
!pip install quandl import os import numpy as np import pandas as pd import pandas_datareader.data as pdr import matplotlib.pyplot as plt import seaborn as sn import pickle import quandl from datetime import datetime import plotly.offline as py import plotly.graph_objs as go import plotly.figure_factory as ff py.init_notebook_mode(connected = True),0)
B. Definindo as funções para download dos dados
Agora definimos a função para baixar e armazenar os dados do Quandl
def get_quandl_data(quandl_id):
'''Baixa e armazena dados do 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
No desenvolvimento de um programa, muitas vezes executamos varias vezes a mesma linha de código. Como nosso acesso aos dados de interesse é feito através de plataformas online, muitas vezes essas plataformas limitam o número de solicitações.
Um número de solicitações excessivo pode sobrecarregar os servidores se realizado em larga escala. Essas plataformas tendem a punir os Ips(Endereço de rede) dos usuários abusivos, restringindo seu acesso.
Para evitar tais consequências, iremos utilizar a função Pickle que previne o download do mesmo arquivo, quando executamos nosso programa repetidamente. A função “pickle” previne o download do mesmo arquivo, quando executamos nosso programa repetidamente.1.1.
C. Obtenção dos dados
Agora iremos obter os dados da casas de câmbio de criptomoedas KRAKEN, obtendo dados do histórico de preços do bitcoin. Na tabela temos as informações de data, preço de abertura, preço de fechamento, valores máximo e mínimo alcançados e seu volume.
O acesso a esses dados do Quandl é limitado para o uso sem declaração de chave da API. Caso você tenha problemas por excesso de limite de tentativas crie uma conta do site , e poderá ter sua própria chave de API, que deve inserir na função [quandl.ApiConfig.api_key = ‘SUACHAVEDAAPI’]
#dados da Kraken preço BTC
quandl.ApiConfig.api_key = 'SUACHAVEDAAPI'
btc_usd_price_kraken = get_quandl_data('BCHARTS/KRAKENUSD')
btc_usd_price_kraken.head()
Gráficos para Análise de Criptomoedas em Python
1. Gráficos de Linha
Para realizar o gráfico de linhas utilizar a função “Scatter”, definindo como eixo x as datas e como eixo y, os preços em dólares.
Caso esteja utilizado o google colab, faz-se necessário o uso da função, “configure_plotly_browser_state”, que permite ao colab a disposição de gráficos interativos da biblioteca “plotly”.
Isso ocorre por conta da falta de parâmetros pelo colab na leitura dos módulos javascript implementados no plotly.
O uso dessa função, corrige essa demandas. Se você usa alguma outro ambiente, como o jupyter por exemplo, o uso dessa função não se faz necessária.
Caso precise utilizar essa função, sua composição completa está disponível em github.com/leomaxil/Python/blob/master/Graficos_bitcoin.ipynb
configure_plotly_browser_state()
btc_trace = go.Scatter(x = btc_usd_price_kraken.index,
y = btc_usd_price_kraken['Weighted Price'])
data = [btc_trace]
py.iplot(data)
Dessa forma temos o gráfico de linhas da série temporal disposto de uma forma interativa, podendo selecionar, qualquer período de tempo que se queira visualizar. É interessante notar que no dia 21/09/2018, ocorreu uma queda repentina no preço do ativo.
Isso ocorreu devido a uma sugestão da Financial Integrity Network(FIN), para o congresso dos Estados Unidos, de criação de uma nova agência reguladora, para regular somente criptomoedas.
Isso fez com que a corretora na qual estamos obtendo os dados, encerrassem negociações, naquele dia.
2. Gráficos Candlestick
Agora a partir dos dados do bitcoin já baixados, iremos implementar um gráfico candlestick. As informações das datas vêm anexadas nos dados como index, precisamos transformá-los em uma variável.
btc_usd_price_kraken['Data'] = btc_usd_price_kraken.index.values
Para a implementação foi utilizada a função candlestick da biblioteca plotly, onde é necessário primeiro definir as variáveis de abertura, fechamento, mínimo e máximo, que são os componentes do candlestick. Como no gráfico de linhas, o gráfico é interativo e podemos selecionar qualquer janela de tempo disponível nos dados.
configure_plotly_browser_state()
py.init_notebook_mode(connected = False)
fig = go.Figure(data = [go.Candlestick(x = btc_usd_price_kraken['Data'],
open = btc_usd_price_kraken['Open'], high = btc_usd_price_kraken['High'],
low = btc_usd_price_kraken['Low'], close = btc_usd_price_kraken['Close'])
])
fig.update_layout(xaxis_rangeslider_visible = False)
py.iplot(fig)
O gráfico candlestick é uma representação de uma janela de tempo, nesse caso em dias, resumindo todo o ocorrido no dia em algumas informações. A cor mostra a valorização ou a desvalorização do valor do ativo no dia em relação ao dia anterior, verde demonstra aumento, vermelho redução no valor. nesse gráfico é possivel observar também preço do ativo quando abriu o mercado, preço do ativo quando fechou, valor máximo e mínimo. No artigo As principais visualizações de criptomoedas eu explico com mais detalhes como interpretar esse gráfico.
3. Gráfico de Linha com Média Móvel
Para avaliar o comportamento da série temporal, iremos suavizar a serie através de médias móveis para distintos intervalos de dias.
Esse tipo de tratamento é bastante utilizado em ativos de alta variabilidade, permitindo, se possível, a visualização de um comportamento global da série. Através dessa suavização cada ponto é representado pela média de seus vizinhos.
A. Obtenção dos dados
Primeiro temos que obter os dados das criptomoedas de interresse.
#Setting the end date to today
end = datetime.today()
#Start date set to one year back
start = datetime(end.year-1,end.month,end.day)
#using yahoo finance to grab cryptocurrency data
BTC = pdr.DataReader('BTC-USD','yahoo',start,end)
ETH = pdr.DataReader('ETH-USD','yahoo',start,end)
LTC = pdr.DataReader('LTC-USD','yahoo',start,end)
XRP = pdr.DataReader('XRP-USD','yahoo',start,end)
TRX = pdr.DataReader('TRX-USD','yahoo',start,end)
EOS = pdr.DataReader('EOS-USD','yahoo',start,end)
DASH = pdr.DataReader('DASH-USD','yahoo',start,end)
B. Definindo o intervalo de tempo
Agora definiremos os intervalos de tempo em 10, 20 e 50 dias, calcularemos uma nova série através de médias moveis, para cada intervalo de tempo, e, compara-los no mesmo gráfico.
configure_plotly_browser_state()
ma_days = [10,20,50]
for ma in ma_days:
column_name = "MA %s days" %(str(ma))
BTC[column_name] = BTC["Adj Close"].rolling(window=ma,center=False).mean()
C. Criando o gráfico de linha com a média móvel
fig = go.Figure()
fig.add_trace(go.Scatter(x=BTC.index, y=BTC['Adj Close'],
mode='lines',
name='Original'))
fig.add_trace(go.Scatter(x=BTC.index, y=BTC['MA 10 days'],
mode='lines',
name='MA 10 days'))
fig.add_trace(go.Scatter(x=BTC.index, y=BTC['MA 20 days'],
mode='lines',
name='MA 20 days'))
fig.add_trace(go.Scatter(x=BTC.index, y=BTC['MA 50 days'],
mode='lines',
name='MA 50 days'))
As janelas de tempo determinam o nível de informação a ser mostrado, na M.A(Média móvel) de 10 dias temos uma série bem próxima da original mas ocultando as variabilidades extremas locais.
Já na M.A de 50 dias o comportamento mostrado de cada dia, reflete o período 50 dias ao redor de cada data, o que é ideal para observar comportamentos lentos mas falha ao representar intervalos menores.
Se olharmos para o dia 25 de outubro de 2019, tanto a série original como as suavizações de 10 e 20 dias demonstram alta, já a suavização de 50 dias mostra queda no preço do ativo.
4. Heatmap
As criptomoedas podem apresentar comportamentos parecidos, especialmente aquelas que compartilham o mesmo estilo de criptografia. Para investigarmos quais criptomoedas podem estar correlacionadas em relação ao seu preço podemos construir um mapa de calor mostrando suas relações.
Agora iremos implementar um Heatmap para criptomoedas, para isso vamos calcular as correlações entre todas as moedas que solicitamos o acesso dos dados.
A. Criando a tabela de preços
Primeiro iremos criar uma tabela, apenas com os preços de fechamento das criptomoedas.
data={'BTC':BTC['Close'],'ETH':ETH['Close'], 'LTC':LTC['Close'],
'XRP':XRP['Close'],'TRX':TRX['Close'],'EOS':EOS['Close'],
'DASH':DASH['Close']}
df = pd.DataFrame(data)
df.head()
B. Criando o gráfico Heatmap
Agora Iremos calcular uma a matriz de correlação entre os preços de fechamento das moedas e implementar o Heatmap.
corrMatrix = df.corr() print (corrMatrix) corrMatrix = df.corr() sn.heatmap(corrMatrix, annot=True) plt.show()
Através do mapa de calor observamos que as moedas XRP(Ripple), TRX(Tron) e EOS apresentam correlações maiores que 90% entre si. Já o Bitcoin não apresenta correlações expressivas com as moedas selecionadas, sendo sua maior correlação de 67% com ETH (Ethereum).
Conclusão
Nesse artigo tivemos uma introdução de como realizar análises gráficas básicas para os dados de criptomoedas, verificando seu comportamento como série temporal e a distribuição dos seus distintos preços, a análise da suavização da série através de médias móveis e a visualização da contaminação dos preços das criptomoedas entre si, através da matriz de correlação.
Referências
https://blog.patricktriest.com/analyzing-cryptocurrencies-python/
https://plotly.com/python/candlestick-charts/
https://medium.com/@melvfnz/how-to-use-python-to-analyze-cryptocurrencies-c5b9601ee0bb
https://blog.kraken.com/post/2732/the-weekly-hash-september-2-6/
[…] artigo https://www.flai.com.br/os-4-graficos-essenciais-para-analise-de-criptomoedas mostro como desenvolver cada um desses gráfico em algumas ferramentas como R, Python, Tableau e […]