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.

segunda-feira, 16 de janeiro de 2017

Introdução ao RCpp - Parte 1.


O R possui uma limitação devido a demora de alguns procedimentos realizados nele. O software foi criado para ser ótimo do ponto de vista de processamento computacional quando o usuário utiliza as informações de maneira vetorizada. Quando o processo é realizado de elemento a elemento alguma demora no processamento surge.

Nesse sentido, aqui daremos uma primeira introdução quanto ao uso do pacote RCpp (http://www.rcpp.org/), o qual permite otimizar alguns procedimentos em R usando linguagem C++.

O primeiro passo para desenvolver suas próprias funções em RCpp é ter instalado:

  1. R
  2. RTools - É preciso que ele esteja instalado na raiz (C:\) e com todas as opções habilitadas.
  3. RStudio

Em seguida, abrimos o RStudio e escolhemos a opção File → New File → C++ File:


O RStudio fornecerá um exemplo de como construir funções usando RCpp:


Onde o primeiro bloco de código, da linha 1 até a 24 é código escrito em C++, o que está contido na linha 26 é o código em R usando para a invocação da função em C++. Para compilar a função é necessário clicar no botão Source destacado na figura anterior. Ao clicar nesse botão a função é compilada e fica disponível para ser executada.

É comum no entanto ter dois arquivos: um arquivo com as funções em C++ e outro arquivo com as funções em R, por isso considere o seguinte código para o arquivo com extensão .cpp:

#include 
using namespace Rcpp;
// This is a simple example of exporting a C++ function to R. 
// [[Rcpp::export]]
NumericVector timesTwo(NumericVector x) {
  return x * 2;
}

E no arquivo em R (com extensão .R):

#Invoca a biblioteca RCpp
library(Rcpp)
#Define o endereço do arquivo Cpp
setwd("C:\\Blog\\Source")
#Compila o código em C++
sourceCpp('Teste.cpp')
#Inova a função compilada
timesTwo(42)

Note que nesse exemplo, Teste.cpp é o nome do arquivo com o código em RCpp armazenado na pasta C:\Blog\Source. No próximo post mostrarei como fazer funções mais complexas envolvendo os pacotes do R e seus objetos com o Rcpp.

quinta-feira, 15 de dezembro de 2016

Mapas Temáticos usando o R - Parte 2.


Como continuação do post Mapas Temáticos usando o R, mostraremos aqui como é possível unir informações pontuais (Point Process) e dados regionais (Lattice Data) além de unir esses dados com o Google maps.

O primeiro passo é a obtenção da malha (shapefile) e dos dados (DadosMapa.csv) para o processo de georeferenciamento.

O primeiro passo é invocar as bibliotecas necessárias bem como definir o Working Directory no qual o arquivo DadosMapa.csv está e também a pasta Shapes

#Limpa o Working Directory
rm(list=ls())
#Define working directory
setwd("C:\\Blog\\ExemploMapas")
#Invoca os pacotes necessários
library(RColorBrewer)
library(maptools)
library(rgdal)
library(rgeos)
library(RgoogleMaps)
library(sp)
library(spdep)
library(ggmap)
library(plyr)
library(Hmisc)

Em seguida, importamos para o R os dados e a malha de interesse:

#Importa os dados
dados<-read.csv("DadosMapa.csv")
#Lê os shapefiles que estão na pasta Shapes dentro do working directory
sfn <- readOGR("Shapes","11MUE250GC_SIR",verbose = FALSE) 
Uma vez lidos os dados e malhas, é preciso saber qual a região devemos importar do GoogleMaps, para isso fazemos:
#Bounding box a ser utilizada no ggmap
b <- bbox(sfn)
#Cria uma variável ID para o georeferenciamento
sfn@data$id <- rownames(sfn@data)
#Define a projeção (Shapefile)
sfn <- spTransform(sfn, CRS("+proj=longlat +datum=WGS84"))
#Cria um SpatialPointsDataFrame com as latitudes e longitudes dos dados
spdf <- SpatialPointsDataFrame(coords=dados[,c("Longitude","Latitude")], data=dados)
#Define a projeção para os pontos
proj4string(spdf) <-CRS("+proj=longlat +datum=WGS84 +no_defs +ellps=WGS84 +towgs84=0,0,0")
#Trasnforma o objeto espacial em um objeto que pode ser lido pelo ggplot2
sfn.df <- fortify(sfn, region="CD_GEOCMU")
#Substring a variável ID para ficar com 6 dígitos (ignora o dígito verificador)
sfn.df$V007<-substr(sfn.df$id,1,6)
#Left Join do CSV com o Shapefile
sfn.df<-merge(sfn.df,dados,by="V007",all.x=T)
#Ordena os dados
sfn.df<-sfn.df[order(sfn.df$order), ] 
Finalmente, após a união dos dados com o Shapefile podemos construir o mapa. Para isso passamos como argumento do ggmap a bounding box obtida nos passos anteriores e definimos também as cores, escalas, títulos do mapa:
#Aumenta ou diminui a Bounding Box (aumenta em 1%)
bbox <- ggmap::make_bbox(sfn.df$long, sfn.df$lat, f = 0.1)
#Escolhe as cores
myPalette <- colorRampPalette(rev(brewer.pal(11, "Spectral")))
#Obtêm o mapa do Google Maps (Existem outras possibilidades...)
map <- get_map(location=bbox, source='google', maptype = 'terrain', color='bw')
#Constrói o mapa:
map <- ggmap(map, base_layer=ggplot(data=sfn.df, aes(x=long, y=lat)), 
             extent = "normal", maprange=FALSE)
map <- map + geom_polygon(data=sfn.df,aes(x = long, y = lat, group = group, fill=Valor), alpha = .6)  
map <- map +   geom_path(aes(x = long, y = lat, group = group),
                         data = sfn.df, colour = "grey50", alpha = .7, size = .4, linetype=2)  
map <- map + coord_equal() 
map <- map + scale_fill_gradientn(colours = myPalette(4))
map<-map+  geom_point(aes(x=Longitude, y=Latitude),color="black", size=1,
                      alpha = 0.70,
                      data=spdf@data)
map<-map +  ggtitle("Postos SINE") +  labs(x="Longitude",y="Latitude") 
#Plota o mapa
plot(map)
Pode-se ainda definir outras bases para o shapefile, alguns exemplos são apresentados a seguir:
##Pode-se trocar o código:
map <- get_map(location=bbox, source='google', maptype = 'terrain', color='bw')
##Do bloco anterior, por algum desses outros:
#map <- get_map(location=bbox, source='osm', color='bw'))
#map <- get_map(location=bbox, source='stamen', color='watercolor'))
#map <- get_map(location=bbox, source='stamen', color='toner'))
#map <- get_map(location=bbox, source='stamen', color='terrain'))
#map <- get_map(location = bbox, source = 'google', maptype = 'terrain')
#map <- get_map(location = bbox, source = 'google', maptype = 'satellite')
#map <- get_map(location = bbox, source = 'google', maptype = 'roadmap')
#map <- get_map(location = bbox, source = 'google', maptype = 'hybrid')

terça-feira, 15 de novembro de 2016

Executando R online com R-FIDDLE.COM


www.R-fiddle.org é um ambiente livre e poderoso para escrever, executar e compartilhar códigos escritos em R.

Esse ambiente ainda oferece a opção de instalar pacotes. Em suma, uma ótima ferramenta para aqueles que querem ensinar ou aprender R sem a necessidade de instalar nenhum arquivo adicional em sua máquina.

Ao entrar no site www.R-fiddle.org observa-se a seguinte tela:


Na parte de baixo os códigos em R são inseridos na forma de Console, por exemplo:


Já na região em branco os códigos são inseridos na forma de Script. Após inseridos os códigos de interesse, basta clicar em Run Code. Os pacotes são invocados normalmente. Ou seja, uma ótima oportunidade para aprender R e compartilhar códigos de maneira simples e direta!!

segunda-feira, 17 de outubro de 2016

Edição Colaborativa em Latex.


Overleaf é um sistema de escrita e publicação colaborativa em Latex que torna todo o processo de produção de trabalhos acadêmicos muito mais rápido para ambos os autores e editores. Overleaf é um serviço gratuito que permite criar, editar e partilhar as suas ideias científicas facilmente online usando Latex, uma ferramenta abrangente e poderosa para a escrita científica.

Uma das vantagens Overleaf é o fato de que essa plataforma apresenta uma diversidade de possíveis templates, facilitando assim a escrita em Latex:


Adtei um modelo da USP para a Universidade de Brasília no Overleaf. Para acessá-lo, clique aqui!

quinta-feira, 15 de setembro de 2016

Equações Estruturais usando lavaan.shiny.


O pacote lavaan.shiny é uma ótima ferramenta para quem possui dificuldades com a programação em R, mas deseja fazer análises complexas envolvendo Equações Estruturais.

#Limpa o Workspace
rm(list=ls())
#Instalçao do pacote lavaan.shiny
install.packages("lavaan.shiny")
#Instalçao do pacote para gráficos
install.packages("DiagrammeR")
#Invoca a biblioteca
library(lavaan.shiny)
#Abre o shiny do lavaan
lavaan.shiny()

Após a execução desse código, o R apresenta uma tela mais amigável para o desenvolvimento dos modelos de Equações Estruturais, a seguir um exemplo de especificação do modelo:


O próprio lavaan.shiny já apresenta um exemplo pronto de um modelo de Análise Fatorial Confirmatória baseado no trabalho de Holzinger, K. J., & Swineford, F. (1939). A study in factor analysis: the stability of a bi-factor solution. Supplementary Educational Monographs.

Para realizar uma análise prática, o primeiro passo é a inserção do banco de dados de interesse. No final da página do lavaan.shiny você deve copiar e colocar os dados. Você pode fazer isso copiando e colando direto do Excel:


Ao continuar descendo na página há ainda outros resultados, como estatísticas descritivas, correlações, estimativas dos parâmetros e também o gráfico de caminhos:


O pacote lavaan.shiny é uma ótima opção para aqueles que desejam trabalhar com modelos como Análise Fatorial Confirmatória e Equações Estruturais sem a necessidade de programação.

A única programação necessária é a instalação do pacote e execução da função lavaan.shiny() todo o resto ocorre em um navegador na máquina do usuário.

segunda-feira, 15 de agosto de 2016

Mapas Temáticos usando o R.


Mapas Temáticos são muito utilizados na etapa de Análise Espacial Exploratória, a qual tem por principal objetivo apresentar visualmente a existência de algum possível padrão espacial.

O objetivo desse post é apresentar como é possível construir Mapas Temáticos usando o R.

O primeiro passo é a obtenção de uma malha digital. Usualmente, uma malha digital é um conjunto de pelo menos três arquivos com o mesmo nome, mas extensões diferentes (*.dbf,*.shx,*.shp). Essa malha nada mais é do que as delimitações geográficas do mapa de interesse. Por exemplo, suponha que desejamos construir um Mapas Temático para os municípios brasileiros, precisamos então da malha municipal.

O principal repositório de malhas digitais no Brasil é do IBGE. Nesse link (ftp://geoftp.ibge.gov.br/malhas_digitais/) podemos obter as mais diversas malhas digitais. Nesse exercício trabalharemos com a malha municipal de 2005.

O código a seguir lê a malha digital (55mu2500pc) e cria uma outra malha somente com o contorno das Unidades da Federação:

#Limpa o Workspace
rm(list=ls())
#Chama a biblioteca
library(ggplot2)
library(rgdal)
library(plyr)
library(rgeos)
#Carrega o objeto SpatialPolygon
br <- readOGR(dsn = ".", "55mu2500pc", verbose=FALSE)
#Faz o dissolve para as UF's
UF <- gUnaryUnion(br, id = br@data$UF)
UF <- fortify(UF, region="UF")
Em seguida, precisamos obter um conjunto de dados que desejamos plotar no mapa. Esse conjunto deve possuir pelo menos uma variável identificada pelo Código do Município também presente na malha 55mu2500pc. Vamos usar como exercício os dados do IpeaData (basta pesquisar no campo Regional pelo tema "Número de homicídios" ou baixe o arquivo aqui.).
#Lê os dados
all_content <- readLines("ipeadata.csv")
#Pula o nome das colunas
skip_first = all_content[-1]
#Lê os dados
indice<- read.csv2(textConnection(skip_first), header = TRUE, stringsAsFactors = FALSE)
#Transforma o NA em zero
indice[is.na(indice)] <- 0
#Corrige o nome dos municípios enconding
indice[,3]<-iconv(indice[,3], "UTF-8", "LATIN2")
indice<-indice[,-9]
colnames(indice)<-c("Sigla","Codigo","Mun","C2005","C2006","C2007","C2008","C2009")

#Renomeia as colunas
indice$GEOCODIGO<-as.character(indice$Codigo)
#Indice de Criminalodade em 2005
indice$Indice<-indice$C2005/sum(indice$C2005)
#Cria as categorias
indice$Categorias1<-cut(indice$Indice,c(0, 0.25,0.50,0.75,1),
                     labels=c('<0.25','0.25|-0.50','0.50|-0.75','>=0.75'))
#Categorias por quartil
breaks<-c(quantile(indice$Indice, probs = seq(0, 1, by = 0.25)))
breaks[1]<-breaks[2]-1e-5
indice$Categorias2<-cut(indice$Indice, breaks=breaks, 
  labels=c("1º Quartil","2º Quartil","3º Quartil","4º Quartil"),
  include.lowest=TRUE)
Agora é preciso unir os dados com a malha:
#Faz o merge com os dados
br@data$id <- rownames(br@data)
#Caso o código tenha apenas 6 dígitos: br@data$IBGE<-substr(br@data$GEOCODIGO,1,6)
br@data   <- join(br@data, indice, by="GEOCODIGO")
#Cria o objeto para ggplot2
br.df <- fortify(br)
br.df <- join(br.df,br@data, by="id")
Em seguida fazemos o mapa:
#Define as cores do mapa
library(RColorBrewer)
myPalette <- colorRampPalette(brewer.pal(11, "Spectral"))
#Faz o mapa
Map <- ggplot(br.df, aes(long, lat)) + geom_polygon(aes(group = group, fill = Categorias2)) + 
  coord_equal() + labs(x = "Longitude", y = "Latitude", fill = "Criminalidade\nRegional") + 
  ggtitle("Índice:\n Criminalidade Regional") + 
  geom_polygon(data=UF, aes(group=group), alpha=1,colour="black", fill=NA, size=0.5)
Map
Caso deseje fazer o mapa com o valor numérico também é possível usar o argumento scale_fill_gradientn:
#Faz o mapa
Map2 <- ggplot(br.df, aes(long, lat)) + geom_polygon(aes(group = group, fill = Indice)) + 
  coord_equal() + labs(x = "Longitude", y = "Latitude", fill = "Criminalidade\nRegional") + 
  ggtitle("Índice:\n Criminalidade Regional") + 
  scale_fill_gradientn(colours = myPalette(4))+
  geom_polygon(data=UF, aes(group=group), alpha=1,colour="black", fill=NA, size=0.5)
Map2

sexta-feira, 15 de julho de 2016

Usando a Biblioteca libSVM no R - Parte 2.


Anteriormente, vimos como executar a biblioteca LIBSVM usando o código em Java. Agora, o exercício é utilizar o código compilado em C++. No Windows é necessário que RTools esteja instalado (Dica:Instale na raiz do computador "C:\").

Esse componente do R instala juntamente com outras funções, o compilador de código fonte em C++ denominado MinGW. Qualquer outro compilador pode ser utilizado nesse exercício.

O próximo passo é obter o código fonte do programa libSVM que desejamos utilizar. Aqui, escolhemos o código desenvolvido por Youngmin Cho disponível aqui (arccos.tar.gz)! Baixe os arquivos e extrai-os em uma pasta (por exemplo C:\Blog\DeepLearning).

Em seguida, fazemos a preparação para a base de dados como no post Usando a biblioteca LIBSVM no R:

#Limpa o Workspace
rm(list=ls())
#Importa os dados German.csv 
setwd("C:\\Blog\\DeepLearning")
library(RCurl)
URL <- "https://dl.dropboxusercontent.com/u/36068691/Blog/german.csv"
x <- getURL(URL)
dados <- read.csv(textConnection(x))
#Separa o vetor de resposta
RESPONSE<-dados$RESPONSE
#Troca zero por -1
RESPONSE[RESPONSE==0]<- -1
#Remove a coluna RESPONSE
dados<-dados[,-32]
O formato exigido pelo LIBSVM deve seguir o formato: [categoria] [coluna1]:[valor1] [coluna2]:[valor2] .... Nesse sentido, fazemos:
#Função para formato libSVM
libsvm<-function(x){
  tt<-cbind(t(x),1:length(x))
  tt<-tt[tt[,1]>0,]
  str<-paste(c(rbind(tt[,2],":",tt[,1]," ")),collapse ="")
  return(str)
} 

#Cria as strings
str<-""
for(i in 1:nrow(dados)){
  x<-dados[i,]
  str<-rbind(str,libsvm(x))
}
str<-str[-1,]

#Adiciona a resposta
txt<-cbind(RESPONSE,str)
txt<-apply(txt,1,function(x) paste(x[1],x[2]))
write.table(txt,"C:/Blog/german",quote=F,row.names=F,col.names=F)
O arquivo german gerado já estará no formato do LIBSVM. Em seguida, precisamos criar os arquivos executáveis por meio do código:
#Criar os executáveis 
system("make all")
Após a criação dos arquivos o resultado que surge no console é:
Criados os arquivos, fazemos a invocação do arquivo executável svm-train:
#Em seguida executamos a função C++
parms<-c("-s 0 "," -t 5 "," -N 0 1 1 "," -d 3 "," -g 1 "," german "," saida")
#Passa os parâmetros
system(paste("svm-train ",paste(parms,collapse = "")))
Os parâmetros devem seguir a notação LIBSVM como a apresentado a seguir:
Após a execução surgem alguns resultados acerca do modelo ajustado:
Após a execução, um arquivo denominado saída é criado e todos os componentes para a previsão do modelo são inseridos nesse arquivo. Se quisermos, por exemplo, avaliar a precisão desse modelo podemos usar o arquivo executável svm-predict na forma a seguir:
#Faz a previsão para um novo conjunto de dados (german)
system("svm-predict german saida resultado.txt")
#Lê os dados preditos de volta para o R
predito<-read.table("resultado.txt")
O comando anterior deve conter três componentes: a base que deseja-se fazer a previsão (validação) aqui denominada german (e deve ter a mesma estrutura da base de treinamento), o arquivo de treinamento (denominado saida) e o arquivo com os valores preditos (aqui denominado resultado.txt). O resultado é apresentado a seguir:

Para outros modelos é necessário executar o mesmo código com variações nos parâmetros e avaliar a acurácia de cada modelo gerado para cada parâmetro selecionado.