Tag

capm Archives - Análise Macro

Seleção de Fatores via Machine Learning no R

By | mercado financeiro

É conhecido que variáveis (comumente ditas como fatores), afetam o excesso de retorno de ações no geral. Um fator bastante difundido é o fator de risco de mercado utilizado no modelo Capital Asset Pricing Model. Nas últimas décadas, a literatura aprofundou-se nos estudos dos fatores que fazem parte da características das empresas, ampliando para o modelo de três fatores de Fama French, que introduziu os fatores Small Minus Big (SMB) e High minus Low (HML). Outros diversos fatores também são utilizados, a depender do mercado a ser investigado. O objetivo do post de hoje será utilizar fatores de investimento em conjunto com uma Regressão de Lasso para ajustar uma série de fatores de risco com o R.

Os fatores de risco são importantes mecanismo para traçar estratégias de investimento, principalmente para entender as características de ativos e antecipar possíveis movimentos de mercado. Como dito, é bem conhecido o fator Risco de Mercado, que leva em conta o risco sistemático produzido por um índice que representa o portfólio de mercado. O fator Small Minus Big (SMB), que representa a diferença do retorno de empresas com baixa capitalização e alta capitalização de mercado. High minus Low (HML), que representa a diferença do retorno de empresas com alto book-to-market e baixo book-to-market.

Outro fatores podem também ser levados em conta, tanto por conta da característica das empresas, quanto por fatores macroeconômicos. Adicionaremos mais três, sendo eles: Winners Minus Losers (WML), que leva em conta o retorno de ações que tiveram altos retornos no passado e ações que tiveram baixo retornos.  Illiquid Minus Liquid (IML) que representa os retornos de ações com baixo liquidez e alta liquidez. E por fim, apenas um representado o fator macroeconômico de juros, que será a taxa de juros livre de risco, também útil para obter o excesso de retorno do ativo e do fator risco de mercado.

Todos os fatores são importados do site da NEFIN, onde também é detalhado a metodologia de criação de cada fator, bem como suas características. Para a ação que será utilizada como variável dependente, escolhemos a ITUB4 de forma totalmente aleatória, representado pelo seu log retorno diário dos preços ajustados.

O modelo utilizado será uma Regressão Lasso, útil para diminuir a limitação da regressão linear, representado pela seguinte equação:

Abaixo, representaremos os códigos para a importação dos dados do ativo selecionado e dos fatores disponibilizados pelo NEFIN.

Após obter todos os dados, nosso objetivo será utilizar a série de funções do universo do Tidymodels para aplicar uma Regressão de Lasso. Primeiro iremos separar os dados de teste e treino, como forma de obter uma ideia do quão bem o modelo ajustou os dados. Selecionaremos o modelo com uma penalidade de 0.0001.

Com as amostras produzidas e o modelo em mãos, podemos rodar com a função fit(), escolhendo a fórmula do modelo e os dados utilizado (no caso a amostra de treino). Obtemos também os valores preditos pelo modelo. Por fim podemos comparar com os dados de teste.

Quer saber mais sobre Finanças?

Veja nossas postagens realizadas sobre o assunto:

E nossos curso aplicados ao Mercado Financeiro:

Referências

Tidy Finance with R. 2022

Estimando o Beta em R e Python

By | mercado financeiro

Um importante conceito do mundo das finanças é o Beta de mercado, no qual mensura a exposição de ações ou portfólios aos movimentos do portfolio de mercado, este sendo representado por índices, tal como o Ibovespa. O método mais comum de avaliar o Beta é através do Capital Asset Pricing Model (CAPM), um modelo de precificação de ativos que a partir da construção do Beta, avalia o retorno esperado de um ativo. No post de hoje introduziremos o conceito de Beta de mercado e o estimaremos através do R e do Python.

O CAPM é um modelo criado na década de 1970, a partir de uma conjunção de estudos protagonizamos pela Teoria Moderna do Portfólio. O CAPM estima o retorno esperado de um ativo com base no retorno de mercado (isto é, o retorno da carteira de mercado, representando aquela carteira que não possui risco idiossincrático ou que somente possui o risco sistemático) e pela Taxa de Juros Livre de risco.

Com o retorno da carteira de mercado representando o risco sistemático, chega-se a conclusão de que as variações do portfólio de mercado representaria um fator importante na variação do retorno de uma ação. Para tanto, na formulação do CAPM foi levado em conta o quanto estes retornos se relacionam, representado pelo Beta de mercado, formando então a seguinte equação calculada através de uma Regressão Linear via MQO:

     $$r_{i,t} -r_{f,t} = \alpha_i + \beta_i (r_{m,t} - r_{f,t}) + \varepsilon_{i,t}$$

em que r_{i,t} -r_{f,t} representa o excesso de retorno de um ativo, dado pela subtração do retorno do ativo em relação ao retorno da taxa de juros livre de risco. r_{m,t} - r_{f,t} o excesso de retorno do portfolio de mercado, sendo representado pela diferença do retorno de mercado e do retorno da taxa de juros livre de risco. \beta_i é o coeficiente da regressão que demonstrará o efeito da variação do excesso de retorno do mercado no excesso de retorno do ativo. \varepsilon_{i,t} é o erro da regressão.

O objetivo então é obter as reais taxas de retorno do ativo e do portfólio de mercado e calcular o Beta de mercado (coeficiente de regressão) . Para tanto, podemos utilizar o R e o Python para coletar os dados e obter o cálculo do Beta de mercado.

A importação dos dados será feita por meio do NEFIN e do Yahoo Finance. Na primeira fonte buscaremos os dados da taxa de juros livre de risco, calculado por meio do DI Swap de 30 dias e o excesso de retorno do mercado, calculado por meio de um portfólio de ações criado a partir de critérios definidos pelo NEFIN e pela diferença com a taxas de juros livre de risco.

Beta no R

O primeiro passo será buscar as séries no site do NEFIN. Utilizaremos a planilha disponibilizada pelo site e devemos realizar algumas manipulações e limpeza para poder utiliza-la.

Com o excesso de retorno da carteira de mercado e a taxa de juros livre de risco em mãos, buscaremos o preço de uma ação como exemplo. Aqui utilizaremos a ação ITUB4, no qual iremos importar através da função tq_get() do pacote {tidyquant}.  Transformamos os preços da ação em log de retornos com a função tq_transmute() como um wrapper da função dailyReturn().


Por fim, rodamos a regressão através da função lm() e obteremos o Beta de Mercado através do Coeficiente Estimado no valor de 1.1472.

Beta no Python

No Python seguiremos o mesmo processo que realizamos no R. Primeiro capturamos os dados do NEFIN, em seguida buscamos o preço de fechamento da ITUB4 e transformamos em log retornos, e por fim calculamos o Beta através de uma regressão.



Regressões Lineares em R e Python

By | mercado financeiro

É comum em nossas vidas construirmos raciocínios lógicos, a partir de acontecimentos do passado, de que tal variável afetou outra. Muitas vezes, lidamos com diversas teorias que demonstram esses raciocínios de forma cuidadosa de acordo com uma história de acontecimentos e de relações entre as variáveis. Mas, e se tivesse uma forma de conseguir estimar, numericamente o efeito dessas relações? Saber se há significância, ou até mesmo, conseguir a partir do efeito numérico prever um resultado? Tudo isso é possível a partir de uma regressão linear, como mostraremos no post de hoje utilizando o R e  o Python.

Regressão Linear

O objetivo principal da Regressão Linear, é a partir de uma equação matemática, definir o efeito de uma ou mais variável independente em uma variável dependente. O nome linear vem justamente da forma de sua equação, no qual define que esse efeito de relacionamentos é uma função linear dos seus parâmetros. Definimos a equação da seguinte forma:

 Y = a + bx+ erro

Nesta equação definimos uma Regressão Linear Simples, pois há somente uma variável independente x, que afeta a variável dependente Y. Ou seja, através desta equação, definimos o efeito de x em Y. O a é uma constante, que mensura o valor da estimativa caso x seja zero. O b (beta) é o parâmetro (ou coeficiente) que mensura a magnitude de uma variação de x em Y. O erro (também conhecido como resíduo) é simplesmente a diferente entre o valor observado de y com o valor estimado pela equação construída de Y, contendo basicamente as variáveis omitidas do modelo.

Para que não  possamos incorrer de muitos erros na Regressão, de forma contenha muitas variáveis omitidas e o valor predito não seja cheio de erros, podemos aumentar o número de variáveis independente de forma que diminua o valor do erro. Sendo assim, construímos uma Regressão Linear Múltipla, denotada pela equação, um pouco mais formal da seguinte forma:

 y = \beta_0 + \beta_1x_1 + \beta_2x_2 + \dots + \beta_k x_k + \varepsilon

Para estimar o valor de  \beta , o método mais comum é através do Mínimo Quadrados Ordinários, que através do conjunto de dados, minimiza o erro, através soma dos quadrados das diferenças entre o valor estimado e os dados observados. Esse tipo de método é mais comum, devido ao fato de que seus pressuposto são menos rígidos. A equação para Beta segue como:

 \hat{\beta} =arg min_{\beta}\sum_{i = 1}^n (y_i - {\beta} x_i)^2

Feito todas as considerações iniciais, podemos partir para um exemplo real no R e Python para exemplificar melhor o conceito de Regressão.

Regressão Linear no R

Criar uma Regressão Linear no R é algo extremamente simples. O que precisamos ter em mãos são os dados da variável dependente e da(s) variável(is) independente(s) e utilizar a função lm() com a fórmula da Regressão como argumento.

Regressão Linear no R: modelo simples de precificação de ativos

Um exemplo para mostrar o efeito de x sobre y ocorre no contexto de finanças, no qual podemos estimar o retorno de um ativo com base no retorno do mercado. Este é um modelo básico que se utiliza a Regressão Linear Simples e é útil para aqueles que queiram entender melhor sobre o efeito prático das relações entre duas variáveis.

Não iremos discorrer muito sobre a importação e transformação de dados. Essa parte ensinamos por completo no nosso curso de R para o Mercado Financeiro.

Importamos os preços de um ativo no R, bem como os pontos do Ibovespa no mesmo período. Transformamos ambos em forma de retorno diário (isto é, a variação do preço de um dia para o outro). O que queremos saber: o quanto a variação do retorno do Ibovespa, tido aqui como o Retorno do Mercado, afeta o Retorno do Ativo?

Após obter nossos dados, podemos utilizar a função lm() para calcular a regressão. Veja que usamos o simbolo ~, significando que o lado esquerdo (PETR4) é em função da direita (^BVSP). Com a função summary(), sumarizamos os resultados da regressão, obtendo os coeficientes, a significância e o R².

A grosso modo, a leitura dos resultados fica como: A estimativa da constante (intercepto) é igual a 0.001769, a estimativa do coeficiente beta dos retornos da Ibovespa é igual a 1.467227. O intercepto possui um p-valor de 0.16, ou seja, não é significante. Já o coeficiente dos retornos do Ibovespa possui um valor de 2e-16, ou seja, é significante. Medido pelo R², a variabilidade do Ibovespa explica 49,13% da PETR4. Por óbvio, não devemos tirar nenhuma relação de causalidade aqui, apenas de relacionamento entre as variáveis.

Um ponto interessante da Regressão Linear é também poder visualizar a relação de duas variáveis. Utilizando um gráfico de dispersão, é possível ver o relacionamento entre as observações das variáveis, também é possível criar uma Reta de Regressão, na qual realiza o ajuste entre a dispersão dos dados.

No R, criamos um gráfico de dispersão com reta de regressão através do pacote {ggplot2}.

Regressão Linear no Python

No Python, seguiremos o processo igual, retirando os mesmo dados da internet e transformando-os em retornos. Para criar a regressão, utilizaremos a função ols() da biblioteca statsmodels e de sey API formula.api.

No código abaixo seguiremos passos iguais que fizemos no R, importando os preços dos ativos e calculando os retornos diários, além de outros tratamentos.

Por fim, criamos a regressão utilizando a smf.ols com a respectiva formula como argumento. Visualizamos os resultados com fit() e summary(). Apesar de ligeiramente diferente do output do R, os principais resultados estão contidos. Há também uma ligeira diferença dos resultado também, devido ao arredondamento dos dados, porém, bem próximos.

Também é possível criar facilmente um gráfico de dispersão com um Reta de Regressão no Python, para isso, utilizamos a biblioteca {seaborn}.

Quer saber mais sobre R e Python?

Veja nossos cursos de aplicados de R e Python para Economistas. Também oferecemos cursos aplicado ao mercado financeiro através do nosso cursos R para o Mercado Financeiro

Calculando o Capital Asset Pricing Model no R

By | mercado financeiro

 

O Capital Asset Pricing Model (CAPM) é um modelo, criado por Willian Sharpe, que busca estimar o retorno de um ativo baseado no retorno do mercado e na relação linear entre o ativo e o retorno do mercado. Essa relação linear é o conhecida como coeficiente beta. No post de hoje, vamos aprender a criar o CAPM Beta através do R. Os códigos de calculo fazem parte do nosso curso R para Mercado Financeiro

Para calcular o CAPM, devemos primeiro estimar o o coeficiente beta, que provem basicamente da regressão do retorno de um determinado ativo sobre o retorno do mercado. Ele captura a relação linear entre o ativo e o mercado. Para nossos propósitos, ele é uma boa forma de explorar um fluxo reprodutível para modelagem de retornos de portfólios sobre o retorno do mercado.

Para a construção do CAPM, utilizamos a seguinte equação.

     $$\mathbb{E}(r_{ativo})=r_f+\beta_{ativo}[\mathbb{E}(r_{mercado})-r_f]$$

Onde  $\beta$ é  $\frac{Cov(R_{ativo}, R_{mercado})}{\sigma^2_{mercado}}$.

Com a equação acima, derivamos os seguintes pontos:

- O portfólio de mercado é eficiente
- O prêmio de risco de um ativo arriscado é proporcional ao seu $\beta$

É importante notar que o portfólio de mercado que gera o CAPM é muitas vezes não-observável, logo a aplicabilidade empírica do modelo pode ser limitada.

Para realizar o calcula do CAPM, utilizaremos os seguintes pacotes.


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

 

Como de praxe, devemos primeiro ter nossos dados em mãos. Utilizaremos os preços de 4 ações brasileiras, bem como os dados do Ibovespa, e calculamos seus retornos mensais para criarmos nosso modelo.


# 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 <- as.Date("2013-12-01")

# Realiza a coleta dos preços diários

prices <- getSymbols(tickers,
auto.assign = TRUE,
warnings = FALSE,
from = start,
src = "yahoo") %>%
map(~Ad(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()

# Coleta o portfólio de mercado (Ibovespa) ----

ibov <-
getSymbols('^BVSP',
from = start,
auto.assign = TRUE,
warnings = FALSE,
src = 'yahoo',)

# Transforma os dados em mensais e em retornos

ibov_returns <-
BVSP$BVSP.Adjusted %>%
`colnames<-`('BVSP') %>%
to.monthly(indexAt = 'lastof', OHLC = FALSE) %>%
Return.calculate(method = "log") %>%
na.omit()

Após o calculo dos retornos, podemos calcular o coeficiente Beta com a função CAPM.beta do pacote {PerformanceAnalytics}. A função utilziar três argumentos, sendo eles os retornos dos ativos, o retorno do portfólio de mercado e o retorno do ativo livre de risco. Nesse exercício, utilizaremos um retorno livre de risco igual a zero.


# Calcula o Beta dos ativos

CAPM.beta(Ra = asset_returns, Rb = ibov_returns, Rf = 0)

Por fim, podemos calcular um portfólio com base nos ativos que temos em mãos e podemos também calcular o CAPM para essa carteira.

# Calcula o retorno do portfolio

portfolio_return <- Return.portfolio(asset_returns)

# Transforma em tibble

portfolio_return_tbl <- portfolio_return %>%
tk_tbl(preserve_index = TRUE,
rename_index = "date")

# Transforma o retorno do ibovespa em tibble

ibov_returns_tbl <- ibov_returns %>%
tk_tbl(preserve_index = TRUE,
rename_index = "date") %>%
rename(ibov_return = BVSP)

# Plota o gráfico de dispersão

portfolio_return_tbl %>%
left_join(ibov_returns_tbl, by = "date") %>%
ggplot(aes(x = ibov_returns, y = portfolio.returns))+
geom_point(color = "#282f6b")+
geom_smooth(method = "lm",
se = FALSE,
color = "red",
size = .5)+
labs(title = "Retornos do portfólio x Retornos da Ibovespa",
x = "",
y = "",
caption = "Elaborado por analisemacro.com.br com dados do Yahoo Finance")+
theme_minimal()


Comparamos os retornos do nosso modelo, criado a partir do CAPM, com os retornos reais.


# Cria o modelo com os valores "fittados"

portfolio_model <-
portfolio_return_tbl %>%
lm(portfolio.returns ~ ibov_returns_tbl$ibov_return, data = .) %>%
augment() %>%
mutate(date = portfolio_return_tbl$date)

# Compara o modelo com o retornos reais

portfolio_model %>%
ggplot(aes(x = date))+
geom_line(aes(y = .fitted,
color = "Retornos"))+
geom_line(aes(y = portfolio.returns,
color = "Retornos CAPM"))+
labs(title = "Comparação - Retornos calculado pelo CAPM x Retornos reais",
x = "",
y = "",
caption = "Elaborado por analisemacro.com.br com dados do Yahoo Finance")+
theme_minimal()+
theme(legend.title = element_blank())

________________________

(*) Para entender mais sobre Mercado Financeiro, seleção de carteira e a Teoria de Markowitz, confira nosso curso de R para o Mercado Financeiro.
________________________

 

Analisando a performance de ativos financeiros

By | mercado financeiro

Sabe-se muito bem que a escolha de ativos financeiros pode ser considerada difícil, afinal, o processo acaba seguindo alguns passos complicados, que talvez muitas pessoas não dominem: definir o objetivo de investimento; escolher a classe de ativos; a política de investimento; definir a forma de alocação dos ativos e por fim, a definição de técnicas para a avaliação de performance dos ativos financeiros escolhidos. Sabe-se que cada pessoa possui formas e gostos diferentes de investir, porém, técnicas de avaliação podem (e devem) superar a subjetividade. No post de hoje mostraremos como podemos simplificar esse processo de avaliação no R.

Assim como nos últimos posts, trabalharemos com quatro ações, apenas para exemplificar o processo. Também trabalharemos com o índice bovespa e com uma taxa de juros livre de risco. Nessa primeira parte iremos coletar o preços e transformar em retornos.

library(quantmod)
library(timetk)
library(tidyverse)
library(PerformanceAnalytics)
library(Hmisc)

 

 

</pre>
# 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 <- "2020-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()

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

# Define taxa de juros livre de risco

rf <- 0.0925/12
<pre>

Feito a coleta e tratamento de dados, podemos enfim analisar nossas escolhas de ativos, mas antes, iremos criar uma função para que possamos exportar nossos resultados do R para uma imagem.

</pre>
# Cria uma função para transformar os resultados de um data frame para texto

df_to_text <- function (result){
textplot(format.df(t(result), na.blank = TRUE, numeric.dollar = FALSE,
cdec = c(3,3,1)), rmar = 0.8, cmar = 2, max.cex = 9,
halign = "center", valign = "top", row.valign = "center",
wrap.rownames = 20, wrap.colnames = 10,
col.rownames = c(rep("darkblue", 5), rep("orange", 2)),
mar = c(0, 0, 3, 0)+ 0.1)
}
<pre>

 

A análise dos ativos são facilitadas pelas funções do tipo table. do pacote PerformanceAnalytics{}. A primeira que podemos utilizar será a table.Stats, que fornece as estatísticas básicas dos nossos ativos.

</pre>
# Resultados estatísticos dos ativos

statistic_result <- table.Stats(asset_returns, digits = 3)

df_to_text(statistic_result)

title(main = list("Estatística dos ativos", cex = 1.5, col = "darkblue"))
<pre>

Veja que é retornado diversas informações estatísticas, desde o número de observações, até a assimetria e curtose, cada um com sua devida interpretação.

Outra função de performance se encontra na table.AnnualizedReturns(), que demonstra o retorno, o desvio padrão e o Índice de Sharpe anualizado.


# Resultados das métricas de performance

performance_result <- table.AnnualizedReturns(asset_returns, Rf = rf, digits = 2)


df_to_text(performance_result)

title(main = list("Performance dos ativos", cex = 2, col = "darkblue"))

Por fim, podemos avançar mais nas técnicas utilizadas, sendo possível ver resultados obtidos pelo Capital Asset Pricing Model.


# Resultados do CAPM

capm_result <- table.CAPM(asset_returns, bvsp_returns, Rf = rf, digits = 2)

df_to_text(capm_result)

title(main = list("CAPM", cex = 2, col = "darkblue"))


Existem diversas outras funções úteis da família table. do pacote PerformanceAnalytics{}, tais como table.DownsideRisk(), table.Drawdowns() e também a função table.Arbritary(), que permite montar, a gosto de cada um, um data frame com os resultados.

 

________________________

(*) 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