Os 4 gráficos essenciais para análise de criptomoedas

Os 4 gráficos essenciais para análise de criptomoedas
As criptomoedas têm tomado a atenção do mercado financeiro, por conta de suas características de trasferibilidade, divisibilidade e aceitabilidade.
No artigo As principais visualizações de criptomoedas, descrevo o funcionamento dessas moedas, da Blockchain e de sua estrutura revolucionária. Pela recente ascensão, essa tecnologia ainda é mal compreendida, levantando dúvidas de como avaliar suas características através de dados.
As visualizações gráficas, são ferramentas poderosas quando se fala em análise de dados, sendo usadas pela maioria dos analistas do mercado financeiro como ferramenta decisiva para negociação de ativos.
Nesse artigo vamos mostrar como obter dados de criptomoedas e como executar algumas visualizações poderosas através da linguagem Python.

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)
O Quandl é um dos mais importante provedores de dados financeiros do mundo, tendo mais 400,000 mil usuários em todo globo, essa plataforma disponibiliza dados gratuitamente, indo de dados corporativos, perfil de profissionais contratados até dados de criptomoedas. Iremos utilizar sua biblioteca e, Python para conseguir nossos dados.

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/

Tags: | | | |

Sobre o Autor

Leonardo Salvi
Leonardo Salvi

Bacharelando em Estatística pela Universidade Federal da Bahia, Pesquisador, Programador e Cientista de dados

1 Comentário


Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *