Tag

ações Archives - Análise Macro

DataReader e Análises com Yahoo! Finance

By | mercado financeiro

Os pontos positivos das linguagens para análise de dados não estão somente inseridos no contexto de manipulação, visualização e modelagem, mas também em um fator extremamente importante para todo o processo de análise: coleta. Foi-se facilitado a importação de dados de diversas fontes da internet, e na finanças não foi diferente. No post de hoje, mostraremos como funciona o processo de coleta de dados financeiros através do Yahoo Finance.

Na internet, existem diversos sites e entre outros tipos de aplicações, que mantem dados em suas páginas ou até mesmo disponibilizam em arquivos .csv, .xlsm, e entre outros formatos.

Com o uso do Python, é possível retirar esses dados rapidamente, de forma relativamente simples, utilizando a raspagem de dados das páginas, ou baixando diretamente os arquivos que guardam o conteúdo. E o mais importante de tudo isso: que também seja reprodutivel.

A sorte é que existem métodos de retirada de dados que são tão úteis, que evoluem para bibliotecas, de forma que seja facilitado ainda mais o processo para todos os usuários. É o caso do DataReader, que possibilita nos ajudar a retirar os dados direto do Yahoo Finance, para que possamos ter mãos as cotações de diversos ativos financeiros.

No código abaixo, iremos realizar alguns exemplos de uso.

Além do datareader, também utilizamos aqui o yfinance, de forma que seja corrigido um problema do datareader que possui problemas na importação do Yahoo Finance. Lembrando também que o datareader permite importados dados de diversas outras fontes, além do Yahoo.

Para coletar os dados dos preços históricos, necessitaremos apenas de uma coisa: o string do ticker do ativo que queremos obter. Para encontrar, é necessário entrar na página https://br.financas.yahoo.com/, procurar o ativo, entrar em sua página e copiar o símbolo que aparece ao lado de seu nome.

 

Veja que além do índice de data, foi importado seis colunas (o que é conhecido como OHLC - Open, High, Low, Close + Adj Close + Volume , neste caso). Que significam o preço de abertura, o preço máximo no dia, o preço mínimo no dia, o preço de fechamento do dia, o preço ajustado por eventos corporativos e o volume de contratos negociados no dia (seguindo a ordem do dataframe).

É possível importar diversos dados. Como por exemplo o Ibovespa (no qual seu símbolo possui um ^).

É possível importar cotações de moedas.

O argumento 'actions', possibilita importar dados de eventos corporativos (dividendos e splits), de forma separadas das cotações, já que há um ajuste padrão contido nesses dados.

Com os argumentos 'start' e 'end', controlamos o período de interesse da coleta, seguindo o padrão 'ano-mês-dia' (yyyy-mm-dd).

Por fim, realizamos um exemplo de como é possível coletar os dados de mais de um ativo de uma vez.

 

Quer aprender mais sobre Python? 

Abrimos hoje, 22/3, as inscrições com 30% de desconto para as Turmas de Outono dos nossos Cursos Aplicados de R e Python. As vagas com esse desconto são limitadas aos primeiros inscritos. Haverá vagas para 25 Cursos Livres e 3 Formações. As turmas de Outono terão início no dia 04/04 e contarão com Cursos de Introdução à Programação em R ou Python, de modo que não é necessário nenhum conhecimento prévio nas linguagens. Para todos os detalhes sobre as Turmas de Outono, entre neste link e garanta sua vaga!

Construindo uma dashboard de ações no R

By | mercado financeiro

O estudo da análise de dados envolve primordialmente transformar dados 'crus' em informação útil, de forma que seja comunicado de forma mais simples possível para que qualquer usuário possa entender. Um meio interessante de transformar esses dados em uma forma simples de visualização é criando uma dashboard. Esse tipo de painel interativo pode ser criado em diferentes áreas de estudos, o que não é diferente para as finanças. No post de hoje, apresentaremos uma dashboard básica para a análise de ações da bolsa de valores criada no R.

A dashboard deverá conter os principais indicadores dos quais o usuário pretende tirar seus insights. Nesta dashboard criada como exemplo, demonstramos o preço da ação, o retorno mensal, o retorno acumulado e o desvio padrão, sendo este um gráfico móvel no qual é possível ter uma estimativa do risco de mercado das ações analisadas. Podemos também colocar inputs dentro dessas dashboard de forma que seja possível ter mais flexibilidade.

Como podem ver na imagem, a barra lateral possui 3 inputs: o nome do ticker da ação (que pode ser encontrado no site do Yahoo Finanças), a data inicial de análise e a janela móvel do desvio padrão (e que funciona somente neste indicador).

Você pode conferir o resultado neste link.

Para criar a dashboard utilizou-se do seguinte YAML:

Com os seguintes pacotes:


library(tidyverse)
library(highcharter)
library(tidyquant)
library(timetk)
library(scales)

A criação da dashboard seguiu como uma junção da Flexdashboard e Shiny, além dos gráficos serem criados através do Highchart.

Sidebar {.sidebar}
=====================================

# Construção dos inputs da barra lateral do dashboard

fluidRow(
column(6,
textInput("stock1", "Stock 1", "VIVT3.SA"))
)


fluidRow(
column(6,
textInput("stock2", "Stock 2", "ITSA4.SA"))
)

fluidRow(
column(6,
textInput("stock3", "Stock 3", "TAEE4.SA"))
)

fluidRow(
column(6,
textInput("stock4", "Stock 4", "BRSR6.SA"))
)

fluidRow(
column(7,
dateInput("date", "Starting Date", "2013-01-01", format = "yyyy-mm-dd"))
)

fluidRow(
column(6,
numericInput("window", "Window", 6, min = 3, max = 20, step = 1))
)

actionButton("go", "Submit")


### Coleta, tratamento e calculos

# Coleta os preços das ações
prices <- eventReactive(input$go, {

symbols <- c(input$stock1, input$stock2, input$stock3, input$stock4)

getSymbols(symbols, src = 'yahoo', from = input$date,
auto.assign = TRUE, warnings = FALSE) %>%
map(~Ad(get(.))) %>%
reduce(merge) %>%
`colnames<-`(symbols)
})

# Transforma os preços xts em mensal

prices_monthly <- eventReactive(input$go, {

prices <- prices()

to.monthly(prices(),
indexAt = "last",
OHLC = FALSE)
})

# Calcula os retornos mensais em xts e wide

asset_returns_xts <- eventReactive(input$go, {

asset_returns_xts <- na.omit(Return.calculate(prices_monthly(),
method = "log"))
})

# Transforma os preços em tibble, mensal e long

prices_monthly_tbl_long <- eventReactive(input$go, {
prices <- prices()

asset_returns_long_tbl<- prices %>%
to.monthly(indexAt = "last",
OHLC = FALSE) %>%
tk_tbl(preserve_index = TRUE,
rename_index = "date") %>%
gather(asset,
prices,
-date)
})

# Calcula os retornos mensais em tibble e long

asset_returns_long_tbl <- eventReactive(input$go, {

prices_monthly_tbl_long <- prices_monthly_tbl_long()

prices_monthly_tbl_long %>%
group_by(asset) %>%
mutate(returns =
(log(prices) - log(lag(prices)))
) %>%
na.omit()
})

# Calcula o retornos acumulado

asset_acum_return_tbl <- eventReactive(input$go, {
asset_returns_long_tbl <- asset_returns_long_tbl()

asset_acum_return_tbl <- asset_returns_long_tbl %>%
group_by(asset) %>%
mutate(acum_return = cumsum(returns))
})

# Calcula o desvio padrão móvel das ações (volatilidade)

rolling_sd_tbl <- eventReactive(input$go, {
rolling_sd_tbl <-
rollapply(asset_returns_xts(),
FUN = sd,
width = input$window) %>%
na.omit() %>%
tk_tbl(preserve_index = TRUE,
rename_index = "date") %>%
gather(asset,
sd,
-date)
})

 

Painel de Acompanhamento
=====================================

Row {data-height=600, .tabset}
-----------------------------------------------------------------------

### Preços

renderHighchart({

hchart(prices_monthly_tbl_long(), type = "line",
hcaes(x = date,
y = prices,
group = asset)) %>%
hc_yAxis(opposite = FALSE) %>%
hc_tooltip(pointFormat = '{point.x: %Y-%m-%d}
R${point.y:.4f}')

})

### Retornos mensais

renderHighchart({

hchart(asset_returns_long_tbl(), type = "column",
hcaes(x = date,
y = returns * 100,
group = asset)) %>%
hc_yAxis(opposite = FALSE,
labels = list(format = "{value}%")) %>%
hc_tooltip(pointFormat = '{point.x: %Y-%m-%d}
{point.y:.4f}% ')

})

### Retornos Acumulados

renderHighchart({

hchart(asset_acum_return_tbl(), type = "line",
hcaes(x = date,
y = acum_return * 100,
group = asset)) %>%
hc_yAxis(opposite = FALSE,
labels = list(format = "{value}%")) %>%
hc_tooltip(pointFormat = '{point.x: %Y-%m-%d}
{point.y:.4f}% ')

})

Row {.tabset .tabset-fade}
-------------------------------------

### Desvio Padrão Móvel

renderHighchart({

hchart(rolling_sd_tbl(), type = "line",
hcaes(x = date,
y = sd * 100,
group = asset)) %>%
hc_yAxis(opposite = FALSE,
labels = list(format = "{value}%")) %>%
hc_tooltip(pointFormat = '{point.x: %Y-%m-%d}
{point.y:.4f}% ')

})

Quer aprender a criar dashboards financeiros? Veja nosso Curso de R para o Mercado Financeiro e Produção de Dashboards.

Calculando o Historical VaR

By | mercado financeiro

O Historical Value at Risk é um método de calculo para mensurar da perda monetária de um determinado portfólio, utilizando como base os valores passados dos ativos e de seus respectivos retornos, criando uma série de Profits e Losses (P&L) que é tomada a um dado nível de intervalo para mensurar a perda potencial.

Assim como o Gaussian Value at Risk, o método Historical é uma das formas mais simples para se calcular o VaR. A diferença é que para o segundo método é necessário que haja mais dados. Neste post, iremos coletar dados de 4 ações para compor nosso portfólio, com dados diários de 1 de janeiro de 2013 até o dia atual.

Primeiro carregamos os pacotes, coletamos os preços e transformamos em retornos.

library(tidyquant)
library(timetk)
library(tidyverse)

 


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

# Calcula os retornos mensais

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

 

Estaremos então interessados em conhecer o valor diário dos nossos ativos dentro do nosso portfólio. Podemos fazer isso através da função Return.portfolio(). A função calcula o retorno do nosso portfólio com base nos retornos dos nossos ativos. Por padrão, a função considera que temos um portfólio com pesos iguais (que é o que utilizaremos aqui, cada ativo terá o peso de 25%). Se utilizarmos o argumento verbose = TRUE, a função também calcula o peso e os valores dos ativos ao longo do tempo.

Suponha então que nosso portfólio possuía um valor monetário de 4563 no primeiro dia, a função retornará uma lista com os retornos do portfólio, os pesos dos ativos e os valores monetários ao longo do tempo.


# Calcula o retorno do portfolio

portfolio_returns <- Return.portfolio(asset_returns, verbose = TRUE, value = 4563)

# Calcular o valor

value <- portfolio_returns$EOP.Value * asset_returns

&nbsp;

p_l <- value[,1] + value[,2] + value[,3] + value[,4]

p_l <- `colnames<-`(p_l, "pl")

var_01_historical <- quantile(-p_l$pl, 0.99)

var_05_historical <- quantile(-p_l$pl, 0.95)

 

Calculamos o P&L como a soma dos valores diários dos ativos ponderados pelos seus respectivos retornos. Por fim, calculamos o quartil para o intervalo de confiança em 99% ou 95%.

 

________________________

(*) Para entender mais sobre Mercado Financeiro e medidas de risco, confira nosso curso de R para o Mercado Financeiro.
________________________

Detectando anomalias com o pacote {anomalize}

By | Hackeando o R

No Hackeando o R de hoje, mostraremos como capturar anomalias de séries temporais de forma rápida e simples. A grosso modo, essas anomalias nas séries aparecem quando eventos não esperados "distorcem" os seus valores, portanto, quando se trabalha com uma análise dos dados, é importante saber quais são esses valores e quando ocorreram, para isso, o pacote {anomalize} nos ajuda nessa tarefa.

O pacote por padrão utiliza o método STL (caso queira se aprofundar no assunto veja esse post), retirando os componentes de tendência e sazonalidade e evidenciando as anomalias.

Iremos utilizar dados de preços e retornos de ações como exemplo, importando-os do ano de 2020 até o dia de hoje. Caso queira saber mais sobre, veja esse post.

 

library(tidyquant)
library(tidyverse)
library(timetk)
library(anomalize)
library(tibbletime)
# 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 <- "2019-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)

# Calcula os retornos mensais

asset_returns <- Return.calculate(prices,
method = "log") %>%
na.omit() %>%
tk_tbl(preserve_index = TRUE,
rename_index = "date")


# Transforma os dados em long

asset_returns_long <- asset_returns %>%
pivot_longer(!date, names_to = "asset", values_to = "value")

Com nossos dados em mãos, podemos utilizar as funções dos pacote. A primeira, time_decompose(), nos fornece a decomposição da série, nos retornando as colunas dos nossos dados atuais observados (observed), os valores da sazonalidade (season), tendência (trend), e o "restante", que são os valores dos dados observados menos a sazonalidade e tendência.

A segunda função, anomalize(), nos fornece a detecção de anomalias, examinando a coluna "remainder".

Por fim, utilizamos a função time_recompose() para calcular os outliers com base nos valores dos dados observados.


# Cria o tibble com valores dos componentes e da anomalia

asset_anomalized <- asset_returns_long %>%
group_by(asset) %>%
time_decompose(value, merge = TRUE) %>%
anomalize(remainder) %>%
time_recompose()

Com os dados em mãos, podemos visualizar através da função plot_anomalies().


# Plota as anomalias dos retornos

asset_anomalized %>%
plot_anomalies(ncol = 4, alpha_dots = 0.25)+
ggplot2::labs(title = "Anomalias nos retornos de ações selecionadas",
caption = "Elaborado por analisemacro.com.br com dados do Yahoo Finance.")


O que nos chama a atenção nas anomalias do nossos dados são as datas de maiores ocorrências,  período do advento da pandemia de COVID-19 no Brasil.

Podemos também verificar essas anomalias nos gráficos de decomposição. Como exemplo, utilizamos o ativo PETR4.


# Transforma em tibble

petr4 <- prices %>%
tk_tbl(preserve_index = TRUE,
rename_index = "date") %>%
select(date, petr4 = `PETR4.SA`)

# Decompõe e calcula as anomalias

petr4_anomalized <- petr4 %>%
time_decompose(petr4) %>%
anomalize(remainder) %>%
time_recompose()

# Plota a decomposição com as anomalias

petr4_anomalized %>%
plot_anomaly_decomposition()+
ggplot2::labs(title = "Decomposição STL e anomalias do preço de fechamento da PETR4",
caption = "Elaborado por analisemacro.com.br com dados do Yahoo Finance.")


Vemos também as anormalidades em grande quantidade no mesmo período.

________________________

(*) Para entender mais sobre análise de séries temporais e mercado financeiro, confira nossos curso de Séries Temporais  e Econometria Financeira.
________________________

Modelo de Mercado e Regressão Móvel

By | mercado financeiro

No post de hoje iremos mostrar como criar o modelo de precificação conhecido como Market Model. O propósito do modelo segue o mesmo caminho que outros modelos de fatores, em que é escolhido uma proxy de risco para explicar a variação do retorno de um ativo. Mostraremos também como criar uma regressão móvel para o modelo.

No caso do Market Model, pode ser considerado um dos modelos mais simples dentro da literatura e do mundo real de finanças, em que é necessário somente os dados de um índice de mercado que queira ser acompanhado, diferente de outros modelos, que se estendem na utilização de proxys para portfolios de mercado ou o efeito do tamanho das empresas sobre o ativo, podendo ou não serem modelos multi-fatores.

O Market Model não pressupõe a preocupação de se utilizar o verdadeiro portfolio de mercado, apenas um índice, portanto não é necessário que seja utilizado a taxa de juros livre de risco para realizar seu cálculo. Sua equação é definida como:

(1)    \begin{equation*}R_i = \alpha + \beta r_m\end{equation*}

em que $r_i$ é o retorno do ativo, $\alpha$ é o retorno em excesso, $\beta$ é o coeficiente que mede a sensibilidade do ativo em relação ao índice e $r_m$ é o retorno do índice.

Feito a especificação do nosso modelo, podemos coletar e tratar nossos dados. Iremos coletar os preços de quatro ações para montar um Equally Weighted Portfolio. Como estamos utilizando ações que estão na B3, iremos utilizar o Índice Bovespa como índice de mercado. Iremos utilizar dados mensais (realizando a transformação de diário para mensal) começando a partir de 2013.

library(tidyverse)
library(tidyquant)
library(timetk)
library(stargazer)
library(ggrepel)
library(patchwork)

# 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 <- "2012-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()

# Calcula o portfolio com pesos iguais

portfolio_returns <- Return.portfolio(asset_returns)

# Coleta os dados do ibovespa

getSymbols("^BVSP",
warnings = FALSE,
from = start,
src = "yahoo")

# Calcula os retornos mensais

bvsp_returns <- Ad(BVSP) %>%
to.monthly(indexAt = "lastof",
OHLC = FALSE) %>%
Return.calculate(method = "log") %>%
na.omit() %>%
`colnames<-`("ibovespa")

# Junta os dados

all_returns <- merge.xts(portfolio_returns, bvsp_returns)

Com os nossos dados em mãos, podemos realizar nossa Regressão via MQO.


# Cálcula a regressão "estática"

market_model <- lm(formula = portfolio.returns ~ ibovespa,
data = all_returns)

# Cria uma tabela com os resultados da regressão

stargazer(market_model, header = FALSE, align = TRUE)

 


Vemos que tivemos um resultado no qual nosso Beta é menor do 1, significando que nosso portfólio varia menos que o proporcional do mercado.

Por fim, sabemos que esse resultado não pode ser o  mesmo em todos os horizontes de tempo, para tanto, podemos criar uma Regressão Móvel para saber em quais período de tempo nosso Beta está acima ou abaixo que o proporcional do mercado.


# Aplica a função para criar a regressão móvel

coef <- rollapply(all_returns,
width = 24, # Janela
FUN = function(x) # Cria uma função da regressão para utilizar com a função
{
roll_reg = lm(portfolio.returns ~ ibovespa,
data = as.data.frame(x))
return(roll_reg$coef)
},
by.column = FALSE)

# Limpa e transforma o objeto em tibble

coef_tbl <- coef %>%
na.omit() %>%
tk_tbl(preserve_index = TRUE,
rename_index = "date") %>%
rename(alpha = "X.Intercept.", beta = "ibovespa")

&nbsp;

# Cria um gráfico do Alpha móvel

alpha <- ggplot(coef_tbl, aes(x = date, y = alpha))+
geom_line(size = .8, colour = "darkblue")+
theme_minimal()+
labs(title = "Alpha",
x = "",
y = "")+
geom_hline(yintercept = 0, linetype = "dashed", colour = "red")+
geom_label_repel(label = round(tail(coef_tbl$alpha, 1), 4),
nudge_y = 0.002,
nudge_x = -1,
data = tail(coef_tbl, 1),
color = 'black',
fill = 'lightblue')

# Cria um gráfico do Beta móvel

beta <- ggplot(coef_tbl, aes(x = date, y = beta))+
geom_line(size = .8, colour = "darkblue")+
theme_minimal()+
labs(title = "Beta",
x = "",
y = "")+
geom_label_repel(label = round(tail(coef_tbl$beta, 1), 3),
nudge_y = 0.2,
nudge_x = -1,
data = tail(coef_tbl, 1),
color = 'black',
fill = 'lightblue')

&nbsp;

# Junta os gráficos

alpha / beta +
plot_annotation(title = "Regressão Móvel do Modelo de Mercado",
subtitle = "Portfólio x Ibovespa",
caption = "Elaborado por analisemacro.com.br com dados do Yahoo Finance.")

 

________________________

(*) Para entender mais sobre Mercado Financeiro e medidas de risco, 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