SAUDAÇÕES!

Seja bem vindo à página do professor Pedro Albuquerque. Para saber mais sobre meu currículo, disciplinas ministradas e interesses de pesquisa, navegue no menu disponível no topo da página.

quarta-feira, 15 de abril de 2015

Text Mining com kernels string no R - Parte 3.


Nesse post daremos continuidade ao que já vimos em posts anteriores como Text Mining com kernels string no R - Parte 1 e Text Mining com kernels string no R - Parte 2. Nessa etapa, vamos tentar reconhecer o padrão das informações prestadas pela Petrobras de 2006 até o primeiro trimestre 2014, para isso, considere os seguintes pacotes:

#Habilita as bibliotecas necessárias
library(tm)
library(wordcloud)
library(Rstem)

Vamos trabalhar com os textos informados pela Petrobras, os quais podem ser obtidos nesse link. Salve esses arquivos em alguma pasta do seu computador, como por exemplo, C:\Text Mining. Em seguida, precisamos transformar os arquivos em PDF para o formato TXT, o qual é possível de ser lido pelo R:

#Seleciona o arquivo de texto a ser minerado
dest<- "C:\\Text Mining\\2006 - 1T.pdf"

#Executa o programa que converte pdf em txt
exe<-"C:\\Program Files\\xpdfbin-win-3.03\\bin64\\pdftotext.exe"
system(paste("\"", exe, "\" \"", dest,"\"", sep= ""), wait= F)

#Cria o arquivo no formato txt
filetxt<- sub(".pdf", ".txt", dest)

#Lê os dados do arquivo
txt<- readLines(filetxt, warn=FALSE)

#Deixa tudo minúsculo
txt<- tolower(txt)

#Remove algumas expressões regulares
txt<-removeWords(txt, c("\\f", stopwords("portuguese")))

#Cria os objetos no formato corpus
corpus<-Corpus(VectorSource(txt))

#Remove a pontuação
corpus<-tm_map(corpus,removePunctuation)

#Remove os números
corpus<-tm_map(corpus,removeNumbers)
Note que o código acima só é possível de ser executado se você tiver instalado o arquivo que converte PDF para TXT, qual seja, Xpdf. Na linha número 5 deve estar o endereço do arquivo executável pdftotext.exe o qual é obtido ao se instalar o programa Xpdf. Cada texto em PDF no arquivo é transformado em TXT e pode ser lido. Para cada texto, podemos associar um retorno obtido no trimestre após a divulgação da informação, por exemplo, para o primeiro trimestre de 2006 temos:
#Coloca os textos na forma de Matriz
tdm<- TermDocumentMatrix(corpus)
m<- as.matrix(tdm)

#Cria um data.frame com a frequência das palavras
d<- data.frame(freq= sort(rowSums(m), decreasing =TRUE))

#Coloca as palavras nas colunas
d$word <- row.names(d)
d$stem<- wordStem(d$word, language="portuguese")

#Remove as palavras muito grandes
d<- d[nchar(row.names(d))<20,]

#Agrega as frequências das palavras
agg_freq<- aggregate(freq ~stem, data = d, sum)
agg_word<- aggregate(word ~stem, data =d, function(x) x[1])

#Une os dados de frequência e palavras
d<- cbind(freq = agg_freq[,2], agg_word)

#Ordena as palavras pela frequência
d<- d[order(d$freq,decreasing =TRUE),]

#1 Trimestre 2006
d$Trimestre<-"1t2006"
d$Retorno<-0.03789927 #Retorno do 2t2006
Uma vez criado um DataFrame para cada texto com o seu respectivo retorno trimestral, podemos usar as frequências das palavras como uma covariável na previsão do retorno trimestral. Essa proposta não é nova e tem sido usada em finanças na busca por padrões. Um bom texto para se começar a estudar esse assunto é o artigo Text mining for market prediction: A systematic review.

segunda-feira, 16 de março de 2015

Text Mining com kernels string no R - Parte 2.


Inicialmente vimos no post Text Mining com kernels string no R - Parte 1 como gerar Wordclouds as quais são úteis na análise descritiva de informação textual, entretanto, podemos fazer algo mais complexo do que simplesmente uma análise descritiva. Podemos reconhecer padrões associados aos textos.

Considere uma lista de 40 textos obtidos da reuters e armazenados no pacote kernlab:

#Habilita o pacote kernlab
library(kernalb)

#Base de notícias da reuters
data(reuters)

#Armazena as palavras chave
y <- rlabels

#Armazena os textos
x <- reuters
Em seguida podemos fazer um Kernel Principal Component Analysis para estudar o padrão das palavras chave:
#Cria o Kernel String
sk <- stringdot(type="spectrum", length=2, normalized=TRUE)

#Faz o Kernel Principal Component Analysis com base nos textos
kpc <- kpca(x,kernel=sk,scale=c())

#Plota o Kernel Principal Component Analysis
plot(rotated(kpc),col=ifelse(y==levels(y)[1],1,2))
Obtendo assim:
O Kernel Principal Component Analysis é uma boa ferramenta para estudar os "tipos" de textos existentes, por exemplo, podemos encontrar textos mais "otimistas", "pessimistas" e atribuir a esses textos um valor quantitativo que pode ser utilizado nos campos de marketing e finanças.

segunda-feira, 16 de fevereiro de 2015

Utilizando RStudio na nuvem com Amazon AMI.


Frequentemente, temos códigos que rodam por horas ou até dias... Impossibilitando o computador para a realização de outras tarefas. Uma solução interessante é "alugar" máquinas que façam essas análises para você.

Hoje está cada vez mais fácil trabalhar com computação em nuvem. Vou mostrar nesse post como utilizar o serviço da Amazon para computação em nuvem com RStudio.

1) O primeiro passo é criar uma conta AWS (Amazon Web Services).

2) Em seguida, vá ao site RStudio Server Amazon Machine Image (AMI). Você pode escolher alguma das regiões disponíveis, para as quais o RStudio já está instalado, como por exemplo, São Paulo:


Nessa etapa você já deve ter sua conta AWS (Amazon Web Services), após preencher com o nome de usário e senha a seguinte tela surge:


Note que há uma lista de possíveis máquinas e configurações disponíveis. Cada máquina possui um valor diferente para o aluguel do serviço. No caso de programação em paralelo deve-se atentar ao número de núcleos (cores) disponíveis e no caso de grandes bases de dados, também na memória RAM disponível.

3) Após escolher a máquina clique no botão Next: Configure Instance Details. Pode aceitar as configurações default e seguir para o próximo passo clicando em Next: Add Storage.

4) Também, nessa etapa (caso não necessite de nenhuma das opções apresentadas) pode seguir para o passo 5) clicando em Next: Tag Instance.

5) Essa é mais uma etapa optativa, não é necessário preencher os campos Key e Value.

6) Essa é mais uma etapa optativa, não é necessário preencher os campos Key e Value. Clique em Next: Configure Security Group.

7) Nessa etapa você deve escolher Type igual a HTTP e nos campos Security group name e Description pode preencher com o nome RStudio:


8) A última etapa para a criação do RStudio Server é clicar no botão Review and Launch. A Amazon irá apresentar as configurações escolhidas e então basta clicar em Launch para criar a instância. Obs: Caso surja uma janela com os dizeres Select an existing key pair or create a new key pair escolha a opção Proceed without a key pair.

Abrindo o RStudio Server na nuvem.

Se as etapas anteriores foram executadas corretamente uma tela como a apresentada abaixo deve surgir:


1)Para abrir o RStudio Server, clique no nome da instância destacada na imagem anterior no retângulo vermelho.

2)Na tela que surgir, procure pelo endereço explicitado em Public DNS. O endereço estará no canto inferior direito da tela. Ao copiar e colar nesse endereço no navegador a seguinte tela aparecerá:


3) Escolha como Username: rstudio e Password: rstudio e então clique em Sign In. Após essas etapas surge:


4) Você deve alterar a senha, para isso, na linha 18, troque o nome "mypassword" pelo nova senha desejada e então execute todo o programa. Pronto! A senha foi atualizada. A partir de agora todo o login deverá ser feito com a nova senha escolhida.

Importando e exportando objetos no RStudio Server.

Caso você tenha alguma base de dados que deseja trabalhar, basta fazer o Upload para o servidor. Basta clicar na opção Upload da aba Files:


Como exercício, fiz o Upload do arquivo german.csv (a descrição da base também está disponível):


Podemos criar alguns novos objetos:

#Importa a base de dados
german.df<-read.csv("german.csv")

#Gera uma variável N(0,1)
x<-rnorm(100,0,1)
Da mesma maneira que podemos fazer o Upload de dados podemos também fazer Download. Por exemplo, se fizermos um histograma:
#Cria o histograma
hist(x)
Podemos salvá-lo em nossa máquina, basta clicar na opção Export:
Em seguida, salve o gráfico na nuvem:
Por fim, escolhemos os objetos que desejamos exportar e clicamos na opção Export:
. Escolha a opção Download:

Interface entre o RStudio Server da Amazon e Dropbox.

Por facilidade, podemos fazer o Download e o Upload de objetos entre o RStudio Server da Amazon e Dropbox. Para isso, além de uma conta no Dropbox, instalar o pacote rDrop. Os passos são: 1) Instale o pacote devtools no RStudio Server da Amazon. 2) Instale o pacote rDrop:
#Habilita o pacote devtools
library(devtools)

#Instala o pacote rDrop
install_github("duncantl/ROAuth")
install_github("karthik/rDrop")
3) Autorize o uso do RStudio Server da Amazon na sua conta do Dropbox. Para isso você precisa criar um App Dropbox developer site. Clique em Create App:
4) Escolha a opção Dropbox Api app:
5) Uma vez que o App foi criado, certifique-se de guardar sua App key e App secret em algum lugar seguro.
#Habilita o pacote rDrop
library(rDrop)

#Insere a App key necessária para a utilização do dropbox
dropbox_credentials <- dropbox_auth("App key", "App secret")
6) Podemos importar dados do Dropbox e exportar dados, basta usar os comandos:
#Salva arquivos no dropbox
?dropbox_save

#Importa arquivos do dropbox
?dropbox_get
Por fim, por se tratar de um serviço PAGO após terminar o uso do RStudio Server Amazon você precisa encerrar a instância, ou então vai continuar pagando pelo serviço. Para isso, basta ir no site AWS onde o servidor foi configurado e na opção Instances parar a instância:
Também é possível encerrar a instância por meio do código:
#Enccerra a instância do RStudio Server na Amazon:
system("sudo shutdown -h now", wait = FALSE)

quinta-feira, 15 de janeiro de 2015

Processamento e paralelo no R.


A computação paralela é uma forma de computação na qual muitos cálculos que são realizados em simultaneamente, aumentando assim a velocidade de execução de determinados códigos. Esse tipo de processamento opera no princípio de que grandes problemas muitas vezes podem ser divididos em partes menores, que são então resolvidos simultaneamente ("em paralelo"). O possível aumento de velocidade máxima de um único programa, como resultado de paralelização é conhecida como Lei de Amdahl.

No R podemos trabalhar com a computação em paralelo por meio de dois pacotes, a saber: foreach e doParallel.

Inicialmente é necessário instalar e carregar os pacotes de interesse:

#Carrega os pacotes necessários para realizar o paralelismo
library(foreach)
library(doParallel)

Cada núcleo existente na sua máquina (ou uma parte deles) pode ser utilizado para se dividir as tarefas e, consequentemente, os cálculos, para isso, precisamos saber quantos núcleos temos disponíveis:

#Checa quantos núcleos existem
ncl<-detectCores()
ncl

#Registra os clusters a serem utilizados
cl <- makeCluster(ncl)
registerDoParallel(cl)
Note que podemos registrar menos clusters do que temos disponíveis, caso você não deseje que sua máquina fique "travada" realizando somente as operações de cálculo exigidas. Para testar a velocidade que o processamento em paralelo trás para o nosso código vamos inicialmente gerar uma base de dados:
#Gera o número de observações
n<-1000

#Variáveis geradas
x<-rnorm(n,0,1)
y<-rnorm(n,1+2*x,2)

#Dataframe com as variáveis geradas
dados<-data.frame(x,y)
Em seguida, vamos realizar o Bootstrap usando a função for usual do R para computar o Erro-Padrão dos parâmetros do modelo de regressão na forma: $y=\alpha+\beta x +\epsilon$ O código é dado por:
#Inicia a contagem do tempo
ptm <- proc.time()

#Cria o vetor para armazenar o parãmetro beta em cada iteração Bootstrap
beta<-rep(0,5000)

#Faz o Bootstrap usando a função for
for(i in 1:5000)
{
  #Gera a amostra Bootstrap
  bdados<-dados[sample(nrow(dados),nrow(dados),replace=T),]
  beta[i]<-unname(lm(y~x,bdados)$coef[2])
}
mean(beta)
sd(beta)

#Para de contar o tempo
proc.time() - ptm
Os resultados para a minha máquina com 4 núcleos e utilizando for foi:
Agora podemos usar a função foreach sem paralelismo para comparar também:
#Inicia a contagem do tempo
ptm <- proc.time()

#Cria o vetor para armazenar o parãmetro beta em cada iteração Bootstrap
beta<-rep(0,5000)

#Faz o Bootstrap usando a função foreach
boot_b <- foreach(i=1:5000, .combine=c) %do% {
  #Gera a amostra Bootstrap
  bdados<-dados[sample(nrow(dados),nrow(dados),replace=T),]
  beta[i]<-unname(lm(y~x,bdados)$coef[2])
}
mean(beta)
sd(beta)

#Para de contar o tempo
proc.time() - ptm
Os resultados foram mais demorados do que utilizando somente o for:
Finalmente, podemos considerar realizar essas tarefas em paralelo, distribuindo os cálculos entre os núcleos registrados:
#Inicia a contagem do tempo
ptm <- proc.time()

#Cria o vetor para armazenar o parãmetro beta em cada iteração Bootstrap
beta<-rep(0,5000)

#Faz o Bootstrap usando a função foreach
boot_b <- foreach(i=1:5000, .combine=c) %dopar% {
  #Gera a amostra Bootstrap
  bdados<-dados[sample(nrow(dados),nrow(dados),replace=T),]
  beta[i]<-unname(lm(y~x,bdados)$coef[2])
}
mean(boot_b)
sd(boot_b)

#Para de contar o tempo
proc.time() - ptm

#Stop clusters
stopCluster(cl)

Usando o paralelismo, o Bootstrap foi muito mais rápido:
Nota-se que o processamento em paralelo realmente é vantajoso, mas outras funções como a família apply, sapply, lapply, mapply, etc. também são muito boas quando deseja-se que o código rode o mais rapidamente possível.

segunda-feira, 15 de dezembro de 2014

Text Mining com kernels string no R - Parte 1.


A Mineração de texto (Text Mining), também denominada de extração de dados de textuais, ou ainda, análise de textual, refere-se ao processo de obter informação quantitativa a partir de um determinado texto.

Essas informações normalmente são obtidas por meio do reconhecimento de padrões e tendências através de aprendizagem estatística. A Mineração de Texto geralmente envolve o processo de estruturação do texto de entrada, reconhecimento dos padrões de dados estruturados, e, finalmente, a avaliação e interpretação dos resultados.

Nesse post mostraremos como realizar algumas das principais tarefas de Text Mining, as quais são úteis no estudo das mídias sociais com propósitos estratégicos gerenciais e de aplicações em marketing.

Análise textual descritiva: Wordcloud.


Uma nuvem de palavras ou Wordcloud é uma representação visual de dados de texto, normalmente usada para descrever os metadados de palavras-chave em textos específicos. Em geral é representada por palavras isoladas, e a importância de cada palavra é mostrada com um tamanho da fonte ou cor. Neste formato é fácil perceber rapidamente os termos mais proeminentes e sua importância relativa.

Considere por exemplo o Soneto da Felicidade:

#Guarda o texto a ser analisado no objeto "soneto"
soneto<-"A Felicidade

Tristeza não tem fim
Felicidade sim

A felicidade é como a pluma
Que o vento vai levando pelo ar
Voa tão leve
Mas tem a vida breve
Precisa que haja vento sem parar

A felicidade do pobre parece
A grande ilusão do carnaval
A gente trabalha o ano inteiro
Por um momento de sonho
Pra fazer a fantasia
De rei ou de pirata ou jardineira
Pra tudo se acabar na quarta-feira

Tristeza não tem fim
Felicidade sim

A felicidade é como a gota
De orvalho numa pétala de flor
Brilha tranqüila
Depois de leve oscila
E cai como uma lágrima de amor

A felicidade é uma coisa boa
E tão delicada também
Tem flores e amores
De todas as cores
Tem ninhos de passarinhos
Tudo de bom ela tem
E é por ela ser assim tão delicada
Que eu trato dela sempre muito bem

Tristeza não tem fim
Felicidade sim

A minha felicidade está sonhando
Nos olhos da minha namorada
É como esta noite, passando, passando
Em busca da madrugada
Falem baixo, por favor
Pra que ela acorde alegre com o dia
Oferecendo beijos de amor"
Uma vez armazenado o texto de interesse, podemos construir a Wordcloud da seguinte forma:
#Habilita as bibliotecas necessárias
library(tm)           #Text Mining
library(wordcloud)    #Wordcloud
Uma vez habilitadas as bibliotecas tm e wordcloud, é necessário transformar o texto em um objeto próprio para análise:
#Transforma os dados de texto em vetores
vs <- VectorSource(soneto)

#Coloca no formato de Corpus do pacote tm
temp<- Corpus(vs)

#Faz o Word Cloud
wordcloud(temp)
O qual fornece a seguinte Wordcloud:
Podemos melhorar a Wordcloud retirando as preposições e artigos desnecessários, tais como: "por", "de", "pelo", "a", etc. Essa etapa consiste em criar um objeto do tipo Corpus para o qual:
  • Converte todas as palavras para minúsculo.
  • Expande todas as contrações de palavra, por exemplo, "pelo" vira "per o".
  • Remove as palavras "ruído".
  • Remove as pontuações.
#Coloca tudo em minúsculo
wc_corpus <- tm_map(temp, tolower)

#Tira a pountuação e palavras ruído
wc_corpus <- tm_map(wc_corpus, removePunctuation)
wc_corpus <- tm_map(wc_corpus, removeWords, stopwords('portuguese'))

#Cria a frequência de palavras
td_mtx <- TermDocumentMatrix(wc_corpus, control = list(minWordLength = 3))
v <- sort(rowSums(as.matrix(td_mtx)), decreasing=TRUE)
df <- data.frame(word=names(v), freq=v)
wordcloud(df$word, df$freq, min.freq=3)
Obtendo assim:
Para deixar mais interessante a Wordcloud fazemos:
#Habilitando o pacote de cores
library(RColorBrewer)
pal2 <- brewer.pal(8,"Dark2")

#Gera o word cloud
wordcloud(df$word, df$freq, min.freq=1,
          max.words=Inf, random.order=FALSE, 
          rot.per=.15, colors=pal2)

sexta-feira, 14 de novembro de 2014

Revolution R - Parte 1.


Hoje uma grande queixa em relação ao uso do R é a dificuldade de lidar com grandes bases de dados (Big Data), nesse sentido, o software Revolution R tem apresentado bons resultados, pois além de lidar com grandes bases de dados utiliza a sintaxe do R para a execução de comandos.

Revolution Analytics é uma empresa de software estatístico focada no desenvolvimento de versões "open-core" do software livre e open source para R. Revolution Analytics foi fundada em 2007 oferecendo apoio e serviços para o software R em um modelo semelhante a abordagem da Red Hat com Linux na década de 1990.

Um bom ponto de partida para entender o Revolution R é pesquisando nos fóruns: http://forums.revolutionanalytics.com/forums/forum.php.

Em 2009, a empresa recebeu nove milhões em capital da Intel, juntamente com uma empresa nomeando Norman H. Nie como seu novo CEO. Em 2010, a empresa anunciou a mudança de nome, bem como uma mudança de foco. Seu principal produto, Revolution R, seria oferecido gratuitamente aos usuários acadêmicos e seu software comercial iria incidir sobre grandes volumes de dados, utilizando multiprocessamento em larga escala e funcionalidade multi-core.

Formato XDF é o formato padrão no Revolution R.


Esse tipo de formato tem como principais características:

  • Armazena dados em blocos para a leitura eficiente de colunas arbitrárias e linhas contíguas.
  • Contém metadados associados, tais como nomes de variáveis​​, descrições e tipos de armazenamento de dados.
  • Suporta um conjunto mais rico de tipos de armazenamento de dados do que R (oito tipos de inteiros, dois tipos de números de ponto flutuante.
  • Escreve blocos de dados de linhas para que o processamento de dados possa ser otimizado.
  • Processa os dados em blocos (grupos de blocos).
  • Otimiza o tamanho dos blocos dependendo da largura de banda do computador individual para I/O.

Uma vez instalado o Revolution R o primeiro passo é criar um projeto:


O interessante é que no Revolution R podemos criar Soluções, Projetos e Scripts. Uma SOLUÇÃO pode conter mais de um PROJETO, e os projetos podem conter um ou mais SCRIPTS. A principal tela do Revolution R é a seguinte:


Suponha que desejamos importar o arquivo Pobreza.csv. Para importar os dados no ambiente Revolution R, basta inserirmos os Snippets. Clique com o botão direito do mouse na tela de Script e escolha:


Em seguida vá na Opção Data Sets:


Escolha a opção Import Data:


Automaticamente, o Revolution R cria a sintaxe básica para importação de dados. Para navegar entre os argumentos da função basta usar a tecla Tab:


Para executar o comando, basta fazer:


Observação: É importante indicar o endereço exato do arquivo Pobreza.csv, como por exemplo:

#Importação dos dados
pobreza.df<-read.table("C:/Pasta/Pobreza.csv",sep=",")

domingo, 13 de janeiro de 2013

Otimização de portfólio por meio do Random Matrix Theory.


A Teoria de Matrizes Aleatórias (Random Matrix Theory - RMT) pode ser utilizada em finanças com o intuito de "filtrar" o ruído presente nas estimativas das estatísticas de interesse como covariâncias e correlações. Essa abordagem tem se mostrado superior a otimização clássica de portifólios como sugerido por Daly, Crane e Ruskin (2007).

Teoria de Matrizes Aleatórias foi inicialmente desenvolvido por Dyson (1962) com o intuito de explicar os níveis de energia de núcleos complexos e tem sido amplamente utilizada no filtro do "ruído" presente em séries temporais financeiras, especialmente em sistemas de grandes dimensões como os mercados de ações.

A ideia é que uma vez que o número de observações e variabilidade são altas nos dados financeiros, as estimativas produzidas para a matriz de variâncias e covariâncias entre os retornos financeiros dos ativos está permeada de ruído e assim, o "verdadeiro" parâmetro pode estar mascarado, fornecendo portfólios sub-ótimos.

Assuma que as matrizes de correlação de variâncias e covariância podem ser expressas da seguinte forma:

$\mathbf{R}=\frac{1}{T}\mathbf{A}\mathbf{A}^{'}$

onde $A$ é uma matriz cujos elementos são independentes e identicamente distribuídos segundo uma $N(0,\sigma^{2})$, então Sengupta e Mitra (1999) mostraram que quando $N\rightarrow\infty$ e $T\rightarrow\infty$ tal que $Q=T/N\geq 1$ é fixado então a distribuição dos autovalores de $\mathbf{R}$ é dada por:

$P(\lambda)=\frac{Q}{2\pi\sigma^{2}}\frac{\sqrt{(\lambda_{+}-\lambda)(\lambda-\lambda_{-})}}{\lambda}$ se $\lambda_{-}\le\lambda\le\lambda_{+}$

onde $\sigma^{2}$ é a variância dos elementos de $\mathbf{A}$ e $\lambda_{\pm}=\sigma^{2}(1+1/Q \pm \sqrt{1/Q})$.

Nesse caso, as matrizes de dados históricos podem ser comparadas com as gerados a partir de retornos aleatórios. Então, somente os autovalores maiores ou iguais a $\lambda_{+}$ conteriam "informação" sobre o Mercado.

Considere os dados:

#Limpa o Workspace
rm(list=ls())

#Habilita o pacote quantmod
library(quantmod)

#Início do período de interesse
inicio = as.Date("2011-01-01") 

#Fim do período de interesse
fim = as.Date("2012-12-31") 

#Ativos
ativos<-c("AMBV4.SA","BBAS3.SA","BBDC4.SA","BISA3.SA","BRFS3.SA","BRKM5.SA","BTOW3.SA","BVMF3.SA","CESP6.SA","CIEL3.SA","CMIG4.SA","CPLE6.SA","CRUZ3.SA","CSAN3.SA","CSNA3.SA","CYRE3.SA","ELET3.SA","ELET6.SA","ELPL4.SA","EMBR3.SA","LIGT3.SA","LREN3.SA","MRFG3.SA","NATU3.SA","PCAR4.SA","PDGR3.SA","PETR3.SA","PETR4.SA","RDCD3.SA","RSID3.SA","SANB11.SA","TIMP3.SA","TRPL4.SA","UGPA3.SA","USIM3.SA","USIM5.SA","VALE3.SA","VALE5.SA")

#Força downloads no Yahoo Finance.
getSymbolsCont <- 
  function(tickers, from=NULL, to=Sys.Date(), src="yahoo") { 
    ok = FALSE 
    n = length(tickers) 
    i = 1 
    while(i <= n | !ok) { 
      
      print(tickers[i]) 
      
      sym = NULL 
      try ( sym <- getSymbols(tickers[i], from=from, to=to, src=src, 
                              auto.assign=FALSE)) 
      
      if(!is.null(sym)) { 
        assign(tickers[i], sym, envir = .GlobalEnv) 
        i = i+1 
        ok=TRUE 
      } else {ok=FALSE} 
      
      Sys.sleep(1) 
    } 
  } 

#Obtêm os dados
series.env <- new.env() 
getSymbolsCont(ativos, src="yahoo",from=inicio,to=fim)

#Une os dados
dados <- merge(AMBV4.SA,BBAS3.SA,BBDC4.SA,BISA3.SA,BRFS3.SA,BRKM5.SA,BTOW3.SA,BVMF3.SA,CESP6.SA,CIEL3.SA,CMIG4.SA,CPLE6.SA,CRUZ3.SA,CSAN3.SA,CSNA3.SA,CYRE3.SA,ELET3.SA,ELET6.SA,ELPL4.SA,EMBR3.SA,LIGT3.SA,LREN3.SA,MRFG3.SA,NATU3.SA,PCAR4.SA,PDGR3.SA,PETR3.SA,PETR4.SA,RDCD3.SA,RSID3.SA,SANB11.SA,TIMP3.SA,TRPL4.SA,UGPA3.SA,USIM3.SA,USIM5.SA,VALE3.SA,VALE5.SA)

#Dados Closing Price
dados.Cl<-Cl(dados)

#Calcula o log-retorno
dados.Cl<-na.omit(apply(dados.Cl,2,function(x)  diff(log(x))))
head(dados.Cl)
O próximo passo é construir a matriz de variâncias e covariância para os dados:
#Matriz de variâncias e covariâncias
R<-nrow(dados.Cl)*as.matrix(cov(dados.Cl))
Em seguida precisamos calcular $\lambda_{+}=\sigma^{2}(1+1/Q + \sqrt{1/Q})$:
#Lambda máximo
A<-as.numeric(chol(R))
A<-A[which(A>0)]
sigma2<-var(A)
Q<-nrow(dados.Cl)/ncol(dados.Cl)
lambda.p<-sigma2*(1+1/Q + sqrt(1/Q))
Nesse caso, fica evidente que há autovalores que são "ruídos" e autovalores "informativos". Laloux et. al. (2000) sugerem a seguinte abordagem: 1 - Calcule a matriz diagonal de autovalores da matriz de variâncias e covariâncias usando decomposição espectral. Nessa primeira etapa, a matriz de variâncias e covariâncias $\mathbf{V}$ pode ser escrita como $\mathbf{V}=\mathbf{E}\mathbf{\Lambda} \mathbf{E}^{-1}$, no R podemos fazer:
#Decomposição espectral
r <- eigen(R)
E <- r[[2]]
Lambda <- diag(r[[1]])
hist(r[[1]])
abline(v=lambda.p,col=3,lty=3)
which(r[[1]] < lambda.p)
2 - Na matriz $\mathbf{\Lambda}$ substitua os autovalores "ruído", ou seja, aqueles que são inferiores a $\lambda_{+}$ pela média de todos os autovalores "ruído" e mantenha os autovalores "informativos" os mesmos. Realizando essa etapa no R temos:
#Lambda Ruídos
iLambdas<-which(r[[1]] < lambda.p)
lambda.medio<-mean(r[[1]][iLambdas])
lambda.filtered<-r[[1]]
lambda.filtered[iLambdas]<-lambda.medio
Lambda.filtered<-diag(lambda.filtered)
3 - A matriz $\mathbf{\Lambda}_{filtrado}$ obtida no passo anterior é combinada novamente por meio da decomposição espectral na forma $\mathbf{V}_{filtrado}=\mathbf{E}\mathbf{\Lambda}_{filtrado} \mathbf{E}^{-1}$. Note que nessa abordagem o traço da matriz $\mathbf{V}_{filtrado}$ é igual a $\mathbf{V}$.
#Encontra a matriz de variâncias e covariâncias filtrada
R.filtered<-E%*%Lambda.filtered%*%solve(E)
4 - Constrói-se as carteiras usando então a matriz $\mathbf{V}_{filtrado}$. Nesse caso desejamos obter os pesos: $w_{i}=\frac{\displaystyle\sum_{j=1}^{n}\sigma_{ij}^{-1}}{\displaystyle\sum_{j,k}\sigma_{jk}^{-1}}$ que minimizam $\mbox{Min }W = \displaystyle\sum_{i,j}w_{i}w_{j}\sigma_{ij}$ onde $\sum_{i=1}^{n}w_{i}=1$ e $\mathbf{V}_{filtrado}^{-1}=\{\sigma_{ij}^{-1}\}$.
#Pesos para os ativos
R.inv<-solve(R.filtered)
pesos<-apply(R.inv,1,function(x)sum(x)/sum(R.inv))
pesos<-cbind(pesos,colnames(dados.Cl))

Abordagem de Plerou.

Plerou et. al. (2002) sugerem ao invés de substituir pela média os autovalores "ruído", substituir simplesmente por zero, e após obter a matriz filtrada na forma: $\mathbf{V}_{filtrado}=\mathbf{E}\mathbf{\Lambda}_{filtrado} \mathbf{E}^{-1}$

Corrigir a diagonal de $\mathbf{V}_{filtrado}$ na forma: $\mbox{diag}(\mathbf{V}_{filtrado})=\mbox{diag}(\mathbf{V})$