Introdução

Aplicações em finanças usando R

Introdução

Pedro Henrique Freire

phfreire@id.uff.br

April 2, 2019
Introdução

1 Introdução
Introdução

Section 1

Introdução
Introdução

Apresentação do curso

Descrição
Iremos fazer um curso focado na parte prática de finanças utilizando o R, será um
curso que irá abordar a ementa abaixo usando para cada aula slides e a aplicação do
que foi visto no dia. Tentaremos manter o mínimo do entendimento teórico mas o
curso será superficial nesse quesito, não iremos focar em demonstrações nem seremos
formais (matematicamente), para isso indicarei livros, matérias e outras fontes.
Mesmo sendo um curso relativamente superficial do ponto de vista teórico e sem pré
requisitos, ao longo do curso iremos abordar diversas ferramentas e técnicas que o R
proporciona, algumas básicas outras intermediárias/avançadas, sendo assim pode
também ser um curso interessante para os que apenas querem aprender R. Teremos
como objetivo a capacidade de entender, aplicar e analizar algumas aplicações para
finanças utilizando o R e falaremos também da integração R/Excel.
Introdução

Onde aprender
Onde eu aprendi
Minicurso no SER
SEMEST
Séries Temporais 1
Séries temporais financeiras (PPGAd)
UFFinance
DataCamp
Coursera
Alocação de ativos de risco
TCC
Artigos, eventos e livros
Outros
Gestão de Portfolio - Análise Macro
Econometria Financeira - Análise Macro
Introdução

O que esse curso é:

Focado em aplicações
Prático
Relativamente superficial
Tentaremos manter o mínimo de entendimento teórico, sempre com as hipóteses
assumidas em mente
O que esse curso não é:
Focado nas demonstrações
Teórico
Formal (matematicamente)
Não vamos cobrir modelos multivariados de volatilidade1

1 Para quem tiver interesse recomendo o livro Multivariate Time Series Analysis - Tsay
e o pacote rmgarch.
Introdução

Ementa resumida
1 Introdução
Introdução à programação
Introdução ao R
Conceitos básicos
Baixando e tratando dados da internet
2 Análise de Carteiras
Introdução
Analisando a performance
Determinantes de performance
Otimizando a carteira - Parte 1
Otimizando a carteira - Parte 2
Passo a passo para otimizar carteiras
Funções objetivo e estimação de momentos
Aplicações
3 Modelos GARCH
Modelo GARCH(1, 1)
Outros modelos GARCH
Validação do modelo
Aplicações
Problemas
4 Integração R e Excel
Introdução

Ementa detalhada e calendário

1 Introdução (02-Abr)
Apresentação do curso
Conceitos básicos
Baixando e tratando dados

2 Análise de Carteiras
1 Introdução (09-Abr)
Primeiros passos
A alocação da carteira
O retorno da carteira
PerfomanceAnalytics
2 Analisando performance (16-Abr)
Dimensões da performance
Índice de Sharpe
Variação da performance no tempo
Não normalidade na distribuição dos retornos
3 Determinantes da performance (23-Abr)
Determinantes no caso de dois ativos
Usando a notação matricial
Orçamento de risco
Introdução

2 Análise de Carteiras
4 Otimizando a carteira - Parte 1 (30-Abr)
Teoria de Markowitz
A fronteira eficiente
Fora vs dentro da amostra
5 Otimizando a carteira - Parte 2 (07-Mai)
Introdução
Desafios
PortfolioAnalytics
6 Passo a passo para otimizar carteiras (14-Mai)
Especificação, restrições e objetivos
Rodando otimizações
Analisando resultados
7 Funções objetivo e estimação de momentos (21-Mai)
Introdução aos momentos
Funções personalizadas de momentos
Funções objetivo
8 Aplicações (28-Mai)
Introdução
Fazendo o backtest
Introdução

3 Modelos GARCH
1 Modelo GARCH(1,1) (04-Jun)
Analisando a volatilidade
A equação GARCH para previsão da volatilidade
O pacote rugarch
2 Extensões do modelo GARCH(1,1) normal (11-Jun)
Não normalidade dos retornos
Efeitos de alavancagem
Modelo da média
Evitando excessos
3 Validação do modelo (18-Jun)
Significância estatística
Qualidade do ajuste
Diagnosticando retornos
Backtesting com ugarchroll
Introdução

3 Modelos GARCH
4 Aplicações (25-Jun)
Value-at-risk
Simulação, validação e execução
Risco do modelo
Covariância do GARCH
5 Problemas (02-Jul)
O problema do otimizador
O problema do modelo univariado

4.Integração do R com Excel (09-Jul)

1 A interface BERT
2 Exemplos
Introdução

Referências:
1 Análise de Carteiras
PerformanceAnalytics Charts and Tables Overview
Introduction to PortfolioAnalytics
Moderna Teoria de Carteiras e Análise de Investimentos - Elton e Gruber.
Active Portfolio Management - Grinold, Kahn
Introduction to Portfolio Analysis in R - DataCamp
Intermediate Portfolio Analysis in R - DataCamp
2 Modelos de volatilidade
GARCH models in R - Kris Boudt, DataCamp
Introduction to the rugarch package - Alexios Ghalanos
Analysis of Financial Time Series - Ruey S. Tsay
GARCH Models - Christian Francq, Jean-Michel Zakoian
Modelling Financial Time Series with S-PLUS - Eric Zivot
Forecasting: Principles and Practices - Rob J Hyndman, George Athanasopoulos
Time Series Analysis - James D. Hamilton
The Econometric Modelling of Financial Time Series - Terence C. Mills
Introduction to Computational Finance and Financial Econometrics - Eric Zivot,
Coursera
Introdução

Ao longo do curso falaremos brevemente sobre alguns conceitos de finanças e de séries

temporais, para aqueles que estiverem interessados em se aprofundar nesses temas
recomendo:

Alocação de Ativos de Risco - André

Derivativos - André
Renda Fixa e Risco - André
Financeira 2
Gestão Financeira de Longo Prazo - Lilian
Avaliação de Empresas - Lilian
Investments - Bodie, Kane & Marcus (“BKM”)
UFFinance - Liga de Mercado Financeiro da UFF
Séries Temporais 1 e 2
Applied Econometric Time Series - Walter Enders
Time Series Analysis - James D. Hamilton
DataCamp
Introdução

Introdução a programação e R

Ao longo do curso utilizaremos o R como ferramenta para aplicarmos as técnicas de

modelagem que serão vistas, para isso é necessário ter conhecimento de diversos
tópicos de programação no R, iremos utilizar conceitos introdutórios de programação,
design de algoritmos, raspagem de dados da Web, computação paralela, vetorização,
otimização, legibilidade etc. Iremos portanto fazer primeiro um nivelamento em
programação no R e os demais conceitos serão apresentados conforme necessário.

Onde aprender programação

Programação de computadores 1 (disciplina do departamento de computação)
Tóp. Esp. em Métodos Estatísticos 1 - Alexei
Seções em algoritmos no livro Fundamentos da Programação de Computadores
- Ana Ascencio, Edilene de Campos
Introduction to Algorithms - Thomas H. Cormen, Charles Eric Leiserson, Ronald
Rivest, Clifford Stein (“CLRS”)

Onde aprender R
Swirl
Introduction to R - DataCamp
Intermediate R - DataCamp
R for Data Science - Hadley Wickham
Introdução

Algoritmos

Definição: Algoritmo é a descrição de uma sequência de passos que deve ser seguida
para a realização de uma tarefa (ASCENCIO, 1999)

Exemplo: Somar três números

Passo 1 - Receber os três números
Passo 2 - Somar os três números
Passo 3 - Mostrar o resultado obtido

Método para a construção de algoritmos

Para construir um algoritmo são necessários os seguintes passos:
Passo 1 - Definir claramente a tarefa
Passo 2 - Definir os dados que devem ser fornecidos (dados de entrada)
Passo 3 - Definir os cálculos que devem ser efetuados (processamento)
Passo 4 - Definir os dados que devem ser gerados (dados de saída)
Passo 5 - Construir o algoritmo
Passo 6 - Testar o algoritmo
Introdução

Tipos de algoritmos

Podemos construir o algoritmo em descrição narrativa, fluxograma ou pseudocódigo.

Descrição narrativa: Consiste em escrever o algoritmo através da linguagem

natural (no nosso caso o português).
Fluxograma: Consiste em escrever o algoritmo através de símbolos gráficos.
Pseudocódigo: Conhecido também como “Portugol” consiste basicamente em
utilizar uma linguagem não computacional mas que segue um conjunto de regras
pré-definidas.
Introdução

Conceito de variável

Um algoritmo recebe dados e tais dados precisam ser armazenados na memória do

computador para serem utilzados no processamento. Uma variável representa uma
posição de memória do computador, possuindo nome e tipo e que o conteúdo pode
variar ao longo do programa (em diferentes instantes no algoritmo).
Tipos de dados (básicos):

Numérico
Lógico
Caractere
Introdução

Identificadores

Formação de identificadores: Os identificadores são os nomes das variáveis, dos

programas, das constantes, das rotinas etc. Essa etapa é muito importante e embora
pareça trivial muitas vezes não é, não se pode usar caracteres especiais ou espaços em
branco, não se pode começar com números e não podemos usar palavras que já
pertencem a uma linguagem de programação. É recomendado seguir algum “Style
Guide”, os dois mais seguidos são o do Hadley e o da Google. Iremos aqui utilizar
nomes apenas com caracteres minúsculos e com palavras separadas por "_", na hora
de formar os identificadores é importante saber balizar concisão e informação.

Exemplo:
prices_ad: Série de preços ajustados.
Introdução

Estrutura sequencial em algoritmos

Pseudocódigo:

ALGORITMO
DECLARE preco_t1, preco_t2, retorno NUMERICO
LEIA preco_t1, preco_t2
retorno <- (preco_t2 - preco_t1)/preco_t1
ESCREVA retorno
FIM_ALGORITMO

No R:

## Calculo do retorno
preco_t1 <- 100
preco_t2 <- 110

retorno <- (preco_t2 - preco_t1)/preco_t1

print(retorno)

## [1] 0.1
Introdução

Estrutura condicional simples em algoritmos

Pseudocódigo:
SE condição
ENTÃO INÍCIO
comando1
comando2
comando3
FIM
No R:
## Calculo do retorno
preco_t1 <- 100
preco_t2 <- 110

retorno <- (preco_t2 - preco_t1)/preco_t1

print(retorno)

## [1] 0.1
if (retorno >0){
print("lucrou")
}

## [1] "lucrou"
Introdução

Estrutura condicional composta em algoritmos

Pseudocódigo:

SE condição
ENTÃO INÍCIO
comando1
comando2
FIM
SENÃO INÍCIO
comando3
comando4
FIM
Introdução

No R:

## Calculo do retorno
preco_t1 <- 100
preco_t2 <- 110

retorno <- (preco_t2 - preco_t1)/preco_t1

print(retorno)

## [1] 0.1

if (retorno >0){
print("lucrou")
}else{
if(retorno < 0){
print("perdeu")
}else{
print("manteve")
}
}

## [1] "lucrou"
Introdução

Estrutura de repetição em algoritmos

Pseudocódigo:

PARA i <- valor_inicial ATÉ valor_final FAÇA

comando1

No R:

## Calculando retornos
precos <- c(100, 110, 90, 105)
retornos <- c()

for(i in 1:length(precos)){
retornos[i] <- (precos[i] - precos[1])/precos[1]
}

print(retornos)

## [1] 0.00 0.10 -0.10 0.05

Introdução

E se quisermos calcular o retorno diário? Podemos fazer isso utilizando estruturas de

repetição! Veja:

## Calculando retornos
precos <- c(100, 110, 90, 105)
retornos <- c()

for(i in 1:length(precos)){
retornos[i] <- (precos[i] - precos[i - 1])/precos[i - 1]
}

print(retornos)

## [1] NA 0.1000000 -0.1818182 0.1666667

Observe que estamos sempre pegando o retorno de um dia (i) menos o retorno do dia
anterior (i - 1), dessa forma quando i for 1 não teremos o retorno pois não temos o
retorno antes do primeiro! Sendo assim o primeiro retorno é NA, e isso faz todo
sentido.
Aqui 1:length(precos) está criando um vetor que vai de 1 até 4 (o tamanho de precos),
então o código aqui vai “trocar” todos os i’s que estão entre as chaves PARA cada
item DENTRO (in) do vetor 1:length(precos), sendo assim ele vai fazer esse passo de
substituição 4 vezes, isto é, em quatro iterações.
Introdução

Vamos ver o passo a passo que a máquina está fazendo por trás, realizando o cálculo
manualmente:

## Calculando retornos
precos <- c(100, 110, 90, 105)
retornos <- c()

# Primeira iteração (i=1)

retornos[1] <- (precos[1] - precos[1 - 1])/precos[1 - 1]
# Segunda iteração (i=2)
retornos[2] <- (precos[2] - precos[2 - 1])/precos[2 - 1]
# Terceira iteração (i=3)
retornos[3] <- (precos[3] - precos[3 - 1])/precos[3 - 1]
# Quarta iteração (i=4)
retornos[4] <- (precos[4] - precos[4 - 1])/precos[4 - 1]

print(retornos)

## [1] NA 0.1000000 -0.1818182 0.1666667

Imagine fazer isso para quatro anos de precos? se você fizesse manual como fizemos
acima seria muito trabalhoso, precisando de 756 contas! Com o for isso fica muito
mais fácil.
Introdução

Vetor em algoritmos

Pseudocódigo:

DECLARE nome[tamanho] tipo

nome[1] <- 1
nome[2] <- 2

No R:

precos <- c(100, 110, 90, 105)

Introdução

Sub-rotinas (programação modularizada)

Sub-rotinas ou subprogramas são blocos de instruções que realizam tarefas específicas.

O código de uma sub-rotina é carregado uma vez e pode ser executado quantas vezes
for necessário. Dessa maneira os programas tendem a ficar menores e mais
organizados, uma vez que o problema pode ser dividido em pequenas tarefas.
Introdução

No R usaremos esse conceito através de funções, por exemplo:

## Funcao para calcular retornos em relacao ao primeiro dia.

calcRet <- function(precos){
retornos <- c()

for(i in 1:length(precos)){
retornos[i] <- (precos[i] - precos[1])/precos[1]
}

return(retornos)
}

## Usando a funcao:
precos <- c(100, 110, 90, 105)
retornos <- calcRet(precos)
print(retornos)

## [1] 0.00 0.10 -0.10 0.05

precos <- c(100, 80, 70, 60, 140)

retornos <- calcRet(precos)
print(retornos)

## [1] 0.0 -0.2 -0.3 -0.4 0.4

Introdução

Baixando e tratando dados

Vamos primeiro pegar os dados da internet usando a função getSymbols do pacote

quantmod. Para calcular os retornos iremos utilizar dados diários de fechamento com
os preços ajustados. Preços ajustados usam o preço de fechamento e incluem efeitos
de splits, dividendos, etc, fatores que apenas mudam a base do preço e não o valor em
si. Mais sobre download de dados financeiros no livro Processamento e Análise de
Dados Financeiros e Econômicos com o R - Marcelo S. Perlin.

library(quantmod)

data <- getSymbols('^BVSP', src='yahoo',

from="2007-01-01", to="2018-12-31",
auto.assign=FALSE)

## Warning: ^BVSP contains missing values. Some functions will not work if
## objects contain missing values in the middle of the series. Consider using
## na.omit(), na.approx(), na.fill(), etc to remove or replace them.

prices <- Ad(data)

colnames(prices) <- '^BVSP'
Introdução

Tratando NA’s A nossa série de preços contem NA’s, NA é um indicador de Not

Avaiable eles indicam dias em que não houve negociação ou dias que a nossa base de
dados não possui informação sobre os preços ajustados. Primeiro vamos ver como é a
cara desses NA’s para termos uma noção de quantos tem e como eles estão
distribuídos para sabermos o quâo eles influenciam os nossos dados, por fim iremos
tratar esses valores.

sum(is.na(prices))

## [1] 8
Introdução

library(Amelia)

missmap(prices, col = c('red', 'navyblue'), y.cex = 0.5, x.cex = 0.8)

Missingness Map
2974
2959
2944
2929
2914
2899
2884
2869
2854
2839
2824
2809
2794
2779
2764
2749
2734
2719
2704
2689
2674
2659
2644
2629
2614
2599
2584
2569
2554
2539
2524
2509
2494
2479
2464
2449
2434
2419
2404
2389
2374
2359
2344
2329
2314
2299
2284
2269
2254
2239
2224
2209
2194
2179
2164
2149
2134
2119
2104
2089
2074
2059
2044
2029
2014
1999
1984
1969
1954
1939
1924
1909
1894
1879
1864
1849
1834
1819
1804
1789
1774
1759
1744
1729
1714
1699
1684
1669
1654
1639
1624
1609
1594
1579
1564
1549
1534
1519
1504
1489
1474
1459
1444
1429
1414
1399
1384
1369
1354
1339
1324
1309
1294
Missing (0%)
1279
1264
1249
1234
1219
1204
1189
1174
1159
Observed (100%)
1144
1129
1114
1099
1084
1069
1054
1039
1024
1009
994
979
964
949
934
919
904
889
874
859
844
829
814
799
784
769
754
739
724
709
694
679
664
649
634
619
604
589
574
559
544
529
514
499
484
469
454
439
424
409
394
379
364
349
334
319
304
289
274
259
244
229
214
199
184
169
154
139
124
109
94
79
64
49
34
19
4
^BVSP
Introdução

prices <- na.omit(prices) #edit# usar omit, locf ou o que? deixar que seja uma e
plot(prices)

prices 2007−01−02 / 2018−12−28

80000 80000

70000 70000

60000 60000

50000 50000

40000 40000

30000 30000

Jan 02 2007 Jan 02 2009 Jan 03 2011 Jan 02 2013 Jan 02 2015 Jan 02 2017 Dec 28 2018