Category

mercado financeiro

Criando uma função de correlação móvel entre ativos financeiros

By | mercado financeiro

No post de hoje, iremos mostrar como é possível calcular a correlação móvel entre ativos financeiros. O objetivo do calculo é acompanhar a relação entre os ativos ao longo do tempo, de forma que, para quem possua uma carteira de ativos saiba quais deles eventualmente se tornem negativamente correlacionado, e portanto, tenham uma carteira diversificada e com baixo risco.

Para quem não sabe, a correlação mede a associação linear entre duas variáveis, ou seja, se há uma correlação positiva entre dois ativos, então ambos, eventualmente se direcionam para a mesma direção, e vice-versa. Importante lembrar que isto não significa qualquer ideia de causalidade.

Para uma carteira de investimentos, estamos obviamente interessados em ativos que se correlacionam negativamente, afim de diminuir o risco da carteira.

Carregamos os pacotes essenciais.

library(Quandl)
library(quantmod)
library(tidyverse)
library(timetk)
library(tidyquant)

Para nosso código, primeiro, devemos buscar os preços dos nossos ativos. Neste post, buscamos 3 ações, o dólar e também a ibovespa.

# Define os tickers das ações coletadas

tickers = c('PETR4.SA', 'ABEV3.SA', 'BBDC4.SA')

# Define o período da coleta

start = '2016-01-01'

# Coleta os preços das ações

prices = getSymbols(tickers, src='yahoo',
                    from= start,
                    warning=FALSE) %>%
  map(~Ad(get(.))) %>%
  reduce(merge) %>%
  `colnames<-` (tickers)

# Transforma os preços diários em mensais, e os transforma em tibble

prices_monthly <- prices %>% 
  to.monthly(indexAt = "lastof",
             OHLC = FALSE) %>% 
  tk_tbl(preserve_index = TRUE,
         rename_index = "date")


# Coleta os dados do IBOVESPA

ibov <- getSymbols("^BVSP", src = "yahoo",
                   from = start,
                   warning = FALSE,
                   auto.assign = FALSE) %>% 
  Ad()


# Transforma o IBOV diário em mensal, e o transforma em tibble

ibov_monthly <- ibov %>% 
  to.monthly(indexAt = "lastof",
             OHLC = FALSE) %>% 
  tk_tbl(preserve_index = TRUE,
         rename_index = "date")


# Coleta o preço do Dólar e o transforma em tibble

cambio = Quandl('BCB/3697',
                order='asc', 
                start_date = start) %>% 
  as.tibble()
  


# Junta todos os preços em um tibble

all_prices <- ibov_monthly %>% 
  inner_join(cambio, by = c("date" = "Date")) %>% 
  inner_join(prices_monthly) %>% 
  rename(cambio = "Value",
         ibov = "BVSP.Adjusted") 

Após realizar toda a coleta e tratamento dos dados, iremos calcular os retornos desses ativos.

# Calcula o retorno contínuo

returns_long <- all_prices %>% 
  pivot_longer(names_to = "asset",
               values_to = "prices",
               -date) %>% 
  group_by(asset) %>% 
  tq_transmute(mutate_fun = periodReturn,
               type = "log")

Por fim, criamos a nossa função de correlação móvel, utilizando a função slidify do pacote {timetk}. Em seguida, calculamos a correlação dos ativos em relação ao Ibovespa e visualizamos no gráfico o resultado.

# Cria uma função de correlação móvel

rolling_cor <- slidify(~cor(.x, .y, use = "complete.obs"), .period = 6, .align = "right")


# Transforma em formato wide

returns_wide <- returns_long %>% 
  pivot_wider(names_from = "asset",
                       values_from = "monthly.returns") 


# Calcula a correlação móvel de cada ativo em relação ao Ibovespa

corr_ibov <- returns_wide %>% 
  transmute(date  = date,
    Dólar = rolling_cor(ibov, cambio),
         PETR4 = rolling_cor(ibov, PETR4.SA),
         ABEV3 = rolling_cor(ibov, ABEV3.SA),
         BBDC4 = rolling_cor(ibov, BBDC4.SA))


# Plota

corr_ibov %>% 
  drop_na() %>% 
  pivot_longer(-date) %>% 
ggplot(aes(x = date, y = value, color = name))+
  geom_line(size = 1)+
  theme_minimal()+
  labs(x = "",
       y = "Correlação",
       title = " Correlação móvel com o IBOVESPA Mensal",
       cation = "Dados: Yahoo Finance e Banco Central do Brasil | Elaboração: analisemacro.com.br",
       color = "Ativo")

________________________

(*) Quer saber mais sobre Mercado Financeiro? Confira nossos curso de Finanças Quantitativas.

________________________

Como calcular o retorno de um portfólio de investimentos

By | mercado financeiro

No post de hoje, como parte do que ensinamos no nosso curso R para o Mercado Financeiro, continuaremos a mostrar como podemos realizar cálculos úteis para avaliações de investimentos. No post passado, mostramos como podemos realizar cálculos dos retorno de ativos individualmente, porém, no mundo real, nem sempre iremos investir nosso dinheiro todo em um único ativo. Por isso, deve-se ser necessário o entendimento de como podemos calcular o retorno de um portfólio de ativos.

Sem muito suspense, o retorno de um portfólio é simplesmente a soma do retorno ponderado pelo peso dos ativos baseado no total de dinheiro investido. De outra forma, podemos definir através de uma equação:

(1)   \begin{equation*} r_p = \frac{I_1}{I_1-I_2} * r_1 + \frac{I_2}{I_1+I_2} * r_2 = w_1 *r_1 + w_2 * r_2 \end{equation*}

onde r_p é o retorno do portfólio, I_1 o dinheiro investido no ativo 1, I_2 o dinheiro investido no ativo 2, r_1 o retorno do ativo 1 e r_2 o retorno do ativo 2.

Nesse caso, utilizamos apenas dois ativos como exemplo na equação, mas o mesmo funciona para caso houver mais ativos no portfólio, sendo necessário apenas expandir a equação.

Mas, como podemos realizar isso no R? É bem simples!

Primeiro iremos carregar os pacotes necessários.

library(quantmod)
library(Quandl)
library(PerformanceAnalytics)
library(tidyverse)
library(timetk)

Em seguida, podemos seguir para o nosso código.


# Define os ativos que irão ser coletados

tickers <- c("PETR4.SA", "ITUB4.SA", "ABEV3.SA", "JBSS3.SA")

# Define a data de início da coleta

start <- "2016-12-01"

# Realiza a coleta dos preços diários

prices <- getSymbols(tickers,
                     auto.assign = TRUE,
                     warnings = FALSE,
                     from = start,
                     src = "yahoo") %>% 
  map(~Cl(get(.))) %>% 
  reduce(merge) %>% 
  `colnames<-`(tickers)

# Transfroma os preços diários em mensais

prices_monthly <- to.monthly(prices,
                           indexAt = "lastof",
                           OHLC = FALSE)

# Calcula os retornos mensais

asset_returns <- Return.calculate(prices_monthly,
                                  method = "log") %>% 
  na.omit()

Veja que até aqui somente tratamos de calcular os retornos individuais dos nossos ativos. Agora, será o momento que devemos realizar o cálculo do retorno do portfólio. Para isso, iremos construir quatro portfólio diferentes, de forma que possamos validar qual a melhor estratégia que podemos utilizar.

Iremos fazer da seguinte forma, através de 4 ativos, com pesos escolhidos aleatoriamente, definimos: PETR4 com peso de 50%; ITUB4 com peso de 27%; ABEV3 com peso de 13% e JBSS3 com peso de 10%.

# Define os pesos dos respectivos ativos

w <- c(0.50, 0.27, 0.13, 0.10)

# Calcula o retorno do portfolio baseado no peso de cada ativo

portfolio_return <- Return.portfolio(asset_returns,
                                      weights = w) %>% 
  `colnames<-`("port_returns")

Através da função Return.portfolio(), calculamos o retorno do portfolio com os retornos individuais e com os pesos escolhidos.

No segundo portfólio, iremos utilizar as mesmas métricas, porém, deixaremos que a função faça um rebalanceamento.

# Calcula o retorno do portfolio baseado no peso de cada ativo com rebalanceamento

portfolio_return_reb <- Return.portfolio(asset_returns,
                               weights = w,
                               rebalance_on = "quarters") %>% 
  `colnames<-`("port_return_reb")

No terceiro portfólio, iremos construir o que a literatura conhece como equally weighted portfolio, no qual estabelece que todos os ativos possuem o mesmo peso.

# Calcula o Equally Weighted Portfolio

portfolio_return_ew <- Return.portfolio(asset_returns) %>% 
  `colnames<-`("ewp")

E por fim, no quarto portfólio, criamos novamente o equally weighted portfolio, porém, com rebalanceamento.

# Calcula o Equally Weighted Portfolio com rebalanceamento

portfolio_return_ew_reb <- Return.portfolio(asset_returns,
                                            rebalance_on = "quarters") %>% 
  `colnames<-`("ewp_reb")

Podemos então visualizar a performance do nosso portfólio através do retorno acumulado, comparando-os entre si, e também com CDI.

Parece que teremos que revisar nossas estratégias.

________________________

(*) Para entender mais sobre Mercado Financeiro e aprender como realizar a coleta, tratamento e visualização de dados financeiros, confira nosso curso de R para o Mercado Financeiro.
________________________

Como transformar preço de ações em retornos

By | mercado financeiro

Quando se fala em estudos financeiros, bem como formas de analisar investimentos, o retorno é a principal medida utiliza para se realizar cálculos e comparações de ativos ao longo do tempo. Existe inúmeros motivos para isso, tanto estatísticos, quanto pela própria teoria e prática de finanças. Hoje, iremos ensinar como transformar os preços de ações em retornos através do R.

Para quem não sabe, o retorno simples de um ativo é dado pela diferença de seu valor no tempo t e t-1 dividido pelo valor no tempo t-1, sendo R_t = (P_t - P_{t-k})/P_{t-k}.

Outro método de cálculo se dá através do Retorno Contínuo: r_t = \text{ln} (P_t/P_{t-k}).

library(tidyverse)
library(PerformanceAnalytics)
library(quantmod)

Para realizar esse cálculo através do R, vamos primeiro coletar o dados de forma reprodutível, utilizando o pacote {quantmod}. Iremos coletar os preços de fechamento de três empresas aleatórias e tratá-las de forma que estejam em um data frame da classe xts.

tickers = c('PETR4.SA', 'ABEV3.SA', 'MGLU3.SA')



prices = getSymbols(tickers, src='yahoo',
                    from='2021-01-01',
                    warning=FALSE) %>%
  map(~Ad(get(.))) %>%
  reduce(merge) %>%
  `colnames<-` (tickers)

Após coletar e tratar os dados, podemos calcular os retornos através da função do pacote {PerformanceAnalytics}, chamada Return.calculate(). É necessário somente o data frame da classe xts do preço dos ativos e especificar o método de calculo dos retornos. No caso, utilizaremos "discrete" para o retorno simples e "log" para o retorno contínuo.

# Calcula os retornos discretos
returns_discrete <- Return.calculate(prices,
                            method = "discrete") %>% 
  na.omit()



# Calcula os retornos contínuos
returns_log <- Return.calculate(prices,
                            method = "log") %>% 
  na.omit()

Podemos plotar os retornos dos nossos ativos.

plot(returns_discrete,
     legend.loc = "topleft",
     main = "Retorno Simples de ativos selecionados")

Podemos também visualizar o retorno cumulativo ao longo do tempo.

chart.CumReturns(returns_log, 
                 legend.loc = "topleft",
                 main = "Retorno Acumulado de ativos selecionados")

________________________

(*) Para entender mais sobre Mercado Financeiro e aprender como realizar a coleta, tratamento e visualização de dados financeiros, confira nosso curso de R para o Mercado Financeiro.
________________________

Coletando e visualizando preços de commodities no R

By | mercado financeiro

No Brasil, é comum acompanhar preços de commodities, afinal, qualquer mudança desses ativos afeta a vida dos brasileiros, seja diretamente ou indiretamente, mesmo para quem não atue no mercado financeiro. No post de hoje, vamos mostrar como é possível coletar dados de commodities e visualizá-los no R.

library(quantmod)
library(tidyverse)
library(timetk)

Após o carregamento dos pacotes, iremos criar os vetores com os tickers dos ativos que iremos coletar. Utilizaremos como fonte o Yahoo Finance, portanto, devemos encontrar os símbolos para a coleta no site.

# Define os tickers que iremos coletar

tickers <- c("KC=F", "NG=F", "CL=F", "SB=F")

Com os símbolos em mãos, podemos retirar os preços a partir do ano de interesse (aqui a partir de 2019), utilizando a função getSymbols(). Em seguida, podemos tratar os dados pegando somente os dados de fechamento e juntando em um só tibble os preços das quatro commodities.

Após isso, transformamos nosso conjunto de dados no formato long, de forma que fique mais fácil utilizar o ggplot para a visualiza-los.

# Retira os preços do Yahoo Finance e realiza o tratamento

prices <- getSymbols(tickers, src = "yahoo",
                     from = "2019-01-01") %>%
  map(~Cl(get(.))) %>% 
  reduce(merge) %>% 
  `colnames<-` (c("Coffee Mar 22", "Natural Gas Dec 21", "Crude Oil", "Sugar #11 Mar 22")) %>% 
  tk_tbl(preserve_index = TRUE,
         rename_index = "date") %>% 
  drop_na()

# Transforma em formato long

prices_long <- prices %>% 
  pivot_longer(cols = -date,
               values_to = "price")


# Plota os preços

prices_long %>% 
ggplot(aes(x = date, y = price, colour = name))+
  geom_line()+
  labs(title = "Preços de Commodities em US$",
       x = "$",
       y = "",
       caption = "Fonte: Yahoo Finance")

Como podemos ver, houve uma escalada de preços do café no ano de 2021. Também é possível notar o momento em que o preço do petróleo cru ficou negativo em abril de 2020.

________________________

(*) Para entender mais sobre Mercado Financeiro e aprender como realizar a coleta, tratamento e visualização de dados financeiros, confira nosso curso R para o Mercado Financeiro.

Lidando com Missing Values em Séries Financeiras

By | mercado financeiro

Podemos dizer que um fato é certeiro na vida de todo Cientista de Dados: encontrar Missing Values. A vida de quem trabalha com finanças também não é diferente, sendo comum encontrar séries financeiras com dados faltantes. Neste post, iremos mostrar como podemos lidar com este problema.

library(quantmod)
library(zoo)
library(knitr)
library(magrittr)
library(timetk)

Vamos aqui trabalhar com a série de preços da MGLU3. Podemos ver através do gráfico que há um NA faltante no dia 26 de fevereiro de 2020.

getSymbols("MGLU3.SA",
                     auto.assign = TRUE,
                     from = "2020-01-01",
                     to = "2020-12-31")

plot(Ad(MGLU3.SA))

Podemos utilizar a função window() para visualizar detalhadamente a data em que nossa série de preços possui dados faltantes.

mglu_na <- window(Ad(MGLU3.SA), 
       start = "2020-02-18",
       end = "2020-03-02")

Agora iremos trabalhar em como podemos lidar com esse NA.

A primeira forma será utilizando a função na.locf(), do pacote {zoo}. Ela permite que o último valor, anterior ao NA, seja repetido para que seja feito esse preenchimento.

na.locf(mglu_na) %>% 
  tk_tbl(preserve_index = TRUE,
         rename_index = "date") %>% 
  kable()

É possível também utilizar o valor adiante ao NA, passando o argumento fromLast = TRUE na função na.locf().

na.locf(mglu_na, fromLast = TRUE) %>% 
  tk_tbl(preserve_index = TRUE,
         rename_index = "date") %>% 
  kable()

Outra forma de resolver o problema, pode ser preenchendo o dado faltante de forma manual, com a função na.fill(), passando no argumento fill o valor desejado.

na.fill(mglu_na, fill = 13) %>% 
  tk_tbl(preserve_index = TRUE,
         rename_index = "date") %>% 
  kable()

Pode-se utilizar a função na.omit() para que o valor seja simplesmente retirado da série de preços.

na.omit(mglu_na) %>% 
  tk_tbl(preserve_index = TRUE,
         rename_index = "date") %>% 
  kable()

Por fim, uma forma interessante é utilizar a função na.approx() do pacote {zoo}. A função realiza uma interpolação linear para preencher o valor faltante.

na.approx(mglu_na) %>% 
tk_tbl(preserve_index = TRUE,
         rename_index = "date") %>% 
  kable()

plot(na.approx(Ad(MGLU3.SA)))

________________________

(*) Para entender mais sobre Mercado Financeiro e aprender como realizar a coleta, tratamento e visualização de dados financeiros, confira nosso curso de R para o Mercado Financeiro.

Receba diretamente em seu e-mail gratuitamente nossas promoções especiais
e conteúdos exclusivos sobre Análise de Dados!

Assinar Gratuitamente
{"cart_token":"","hash":"","cart_data":""}