Category

Hackeando o R

Hackeando o R: acessando os dados do datasus com o R

By | Hackeando o R

Dentro do universo do R, cada vez mais tem sido facilitado o acesso a diversos tipos de dados. Para tanto, O pacote {microdatasus} tem como principal propósito a importação dos microdados do DATASUS, este sendo um sistema do estado brasileiro de apoio a conexão e suporte de informações sobre a saúde com os entes federativos. No Hackeando o R de hoje, iremos dar uma olhada sobre o pacote.

Antes de tudo é necessário realizar o download do pacote, que se encontra no repositório do autor no github.


# remotes::install_github("rfsaldanha/microdatasus")

library(microdatasus)
library(tidyverse)

O pacote se separa em dois tipos de funções, a primeira  sendo fetch_datasus(), que consiste na função que realiza o download dos dados. E o segundo tipo, que se refere ao pré-processamento dos dados, sendo eles: process_sim(), process_sinac() e process_sih().

Para importar os dados mostraremos exemplos da função fetch_datasus().

(obs: antes de replicar o código, certifique que sua máquina pode lidar com grandes quantidades de dados. O processo pode demorar um pouco).

# Sistema de Informação sobre Mortalidade de Minas Gerais de 2019

data_sim_mg <- fetch_datasus(year_start = 2019,
year_end = 2019,
uf = "MG",
information_system = "SIM-DO")

# Sistema de informação Hospital Descentralizada de Minas Gerais de 2019
data_sih_mg <- fetch_datasus(year_start = 2019,
year_end = 2019,
month_start = 1,
month_end = 12,
uf = "MG",
information_system = "SIH-RD")

# Sistema de informações sobre Nascidos Vivos de Minas Gerais de 2019

data_sinasc_mg <- fetch_datasus(year_start = 2019,
year_end = 2019,
uf = "MG",
information_system = "SINASC")

Trataremos de pegar somente dados de um único ano, já que são grandes quantidade de dados. Dependendo da máquina, pode demorar um pouco o tempo de download.

Ao seguir a etapa, agora é preciso tratar os dados com as respectivas funções de cada sistema.


# Trata os dados do SIM

sim_mg <- process_sim(data_sim_mg)

# Trata os dados do SIH

sih_mg <- process_sih(data_sih_mg)

# Trata os dados do SIA

sinasc_mg <- process_sinasc(data_sinasc_mg)

As variáveis dos dados de cada sistema possuem uma forma especial de lidar, além de seus nomes serem processados em abreviações. Para obter a informações de todas as variáveis e suas convenções, é recomendável checar o repositório do github do pacote.


# Seleciona os dados de interesse: Estado civil da mãe e Sexo do bebê

sinasc <- sinasc_mg %>%
select(ESTCIVMAE, SEXO) %>%
na.omit()

# Visualiza os número de Mães por Estado Civil

sinasc %>%
count(ESTCIVMAE) %>%
ggplot(aes(x = ESTCIVMAE, y = n,
fill = ESTCIVMAE,
color = ESTCIVMAE,
label = n))+
geom_bar(stat = "identity")+
geom_label(color = "black")+
labs(title = "Estado Civil das Mães de Nascidos em Minas Gerais",
subtitle = "ano de 2019",
x = "",
y = "",
caption = "Elaborado por analisemacro.com.br com dados do DATASUS")+
theme_minimal()+
theme(legend.position = "none")


# Visualiza o número de bebês por sexo

sinasc %>%
count(SEXO) %>%
ggplot(aes(x = SEXO, y = n,
fill = SEXO,
color = "SEXO",
label = n))+
geom_bar(stat = "identity")+
geom_label(color = "black")+
labs(title = "Sexo dos bebês nascidos em Minas Gerais",
subtitle = "ano de 2019",
x = "",
y = "",
caption = "Elaborado por analisemacro.com.br com dados do DATASUS")+
theme_minimal()+
theme(legend.position = "none")

 

 

________________________________

Na Análise macro oferecemos cursos que ensinam você a como lidar com o micro dados e análise de dados. Veja nossa trilha de Micro dados e nosso curso de R para análise de dados.

________________________________

Hackeando o R: criando relatórios customizados com o pacote {pagedreport}

By | Hackeando o R

Quando se está interessado na montagem de relatórios, o Rmarkdown é a primeira ferramenta que se passa na mente, afinal, ele facilita na construção de apresentação com o R em PDF. Apesar disso, há a dificuldade da criação de relatórios com visuais mais elegantes. Para suprir esta demanda, o pacote {pagedreport} facilita o trabalho de customizar PDFs gerados pelo Rmarkdown. No Hackeando o R de hoje, vamos mostrar um pouco sobre esse pacote.

O pacote, até o momento, possui 3 temas principais, cada um com seu próprio estilo e que também podem ser alterados suas configurações visuais padrão conforme aquela que melhor atende, sendo possível alterar cores, fontes e imagens utilizas pelo tema. Para utilizar o pacote, primeiro ele deve ser baixado através do Github.


remotes::install_github("rfortherestofus/pagedreport", ref = "main")

Após a instalação (é recomendado reiniciar o Rstudio), para criar sua primeira apresentação com o {pagedreport}, vá em File > New File > R markdown > From Template. Veja, como na imagem abaixo, que aparecerá três opções ligadas ao {pagedreport} , cada uma representando um tema que melhor agrada, conforme as necessidades de cada um. Para prosseguir com a criação, selecione uma opção e clique em Ok.

Ao prosseguirmos, será aberto um arquivo .Rmd com os códigos iguais a imagem abaixo. Veja que se comparar o YAML com documentos Rmarkdown padrão, verá que não há nada de assustador.

 

  • title: título,
  • subtitle: subtítulo
  • author: autor
  • date: data

O que realmente muda é a parte após o output, no qual contém o uso do pacote e suas respectivas configurações.

No caso, vemos algumas opções, além de setar o template que utilizado  com pagedreport::paged_grid:, é configurado a logo, por meio de um link da internet (recomendável, pois dessa forma pode se tornar reprodutível), o knit e a cor principal do PDF.

Outros template podem vir com configurações a mais ou que podem ser adicionadas, como:

  • front_img: configura a imagem da capa.
  • back_img: altera a imagem da capa do fundo.
  • img_to_dark: TRUE ou FALSE, escure as imagens de capa e fundo.
  • logo_to_white: TRUE ou FALSE, transforma a imagem do logo em branco.
  • secondary_color: altera a cor secundária.

Outras possíveis seções de configuração do YAML condensam as padrões do Rmarkdown.

_________________________________________

Fizemos aqui uma introdução de como customizar seus relatórios PDFs de forma simples. Caso queira se aprofundar na apresentação de relatórios, conhecer mais sobre Rmarkdown e entender melhor o pacote {pagedreport}, é importante que confira nosso Curso de produção de Relatórios em Rmarkdown.

_________________________________________

 

Hackeando o R: criando temas no ggplot2

By | Hackeando o R

Quando o assunto é visualização de dados no R, é quase impossível não se lembrar do {ggplot2}. O pacote  se tornou quase que padrão na comunidade, e isso não foi ao acaso, de fato ele realmente é um dos melhores no sentido de criar gráficos seja de quaisquer tipos, sendo simples e flexível. No Hackeando o R de hoje ensinaremos alguns pontos básicos sobre como personalizar seu próprio tema com o {ggplot2}.

Antes de tudo, é importante saber alguns conceitos do pacote. Para sua utilização, é necessário especificar na função ggplot() o  data frame que irá ser utilizado, e também mapear os eixos x e y com a função aes(), de acordo com as colunas do conjunto de dados.

library(ggplot2)
ggplot(economics, aes(x = date, y = pce))

Porém, somente essa parte da função não é suficiente, portanto,  ele se divide em "subfunções", cada qual com seu respectivo propósito para a construção dos gráficos. São eles:

  • layer: coleção de elementos geométricos que formam os desenhos dos gráficos, são conhecidos pelas funções que iniciam com geom_ ou stats_.
  • scale: funciona como forma de alterar as escalas do gráfico em consonância com o espaço mapeado pelos valores que são inseridos.  Iniciam com scale_
  • coord: descreve como os dados coordenando se inserem no plano do gráfico, por padrão segue o cartesiano, no qual os valores de x e y se combinam. Iniciam com coord_
  • facet:  utilizada para criar diversos gráficos com base em diferentes categorias do dataset. Iniciam com facet_
  • theme: controla as cores, fontes, linhas e entre outros. Em suma, toda a parte visual do gráfico e que não faz parte dos dados. São criados com a função theme().

Dito isto, focaremos na estrutura da montagem de temas com o theme, que se separam em três subclasses: text, line e rectangle, cada uma com o proposito de alterar os elementos visuais do gráfico. Para cada subclasse existe um argumento específico de mudança e uma função padrão em que é utilizado para mudar as cores, fontes, tamanhos e entre outros. Vamos ver detalhadamente para cada tipo.

A primeira é o text, que controla toda a parte de texto do gráfico. Dentro da função themes(), é possível mudar desde todos os textos do gráfico com o argumento text =, e também é possível ser mais especificar, por exemplo, utilizando o argumento title =, em que é mudado apenas o texto do título.

Para realizar as mudanças, é necessário que após especificar o argumento do texto, para realizar as mudanças, é necessário utilizar a função element_text(). Exemplo:

ggplot(economics, aes(x = date, y = pce))+
geom_line(size = .8, colour = "darkblue")+
theme(title = element_text(color = "blue"))

Vemos a mudança no título do texto. Abaixo, segue os possíveis argumentos que podem ser utilizados para realizar as mudanças.

theme(
text,
 axis.title,
   axis.title.x,
      axis.title.x.top,
      axis.title.x.bottom,
    axis.title.y,
       axis.title.y.left,
       axis.title.y.right,
  title,
     legend.title,
     plot.title,
     plot.subtitle,
     plot.caption,
     plot.tag,
  axis.text,
   axis.text.x,
    axis.text.x.top,
    axis.text.x.bottom,
   axis.text.y,
    axis.text.y.left,
    axis.text.y.right,
legend.text,
strip.text,
   strip.text.x,
   strip.text.y)

O tipo line controla toda a parte de linhas dentro do plano do gráfico. Também é controlada a partir de argumentos próprios, com seus respectivos propósitos, além de possuir a sua própria função, chamada de element_line(). Exemplo:

ggplot(economics, aes(x = date, y = pce))+
geom_line(size = .8, colour = "darkblue")+
theme(axis.line = element_line(color = "blue"))

Abaixo, os argumentos próprios do tipo line.
theme(
line,
    axis.ticks,
      axis.ticks.x,
        axis.ticks.x.top,
        axis.ticks.x.bottom,
      axis.ticks.y,
       axis.ticks.y.left,
       axis.ticks.y.right,
    axis.line,
       axis.line.x,
         axis.line.x.top,
         axis.line.x.bottom,
       axis.line.y,
          axis.line.y.left,
          axis.line.y.right,
    panel.grid,
        panel.grid.major,
           panel.grid.major.x,
           panel.grid.major.y,
        panel.grid.minor,
           panel.grid.minor.x,
           panel.grid.minor.y)

Outro tipo é o rectangle, que altera toda a parte retangular dentro e fora do plano, além de alterar o retângulo que se encontra na legenda. Possui também seus próprios argumentos e sua função chamada element_rect(). Exemplo:

ggplot(economics, aes(x = date, y = pce))+
geom_line(size = .8, colour = "darkblue")+
theme(panel.background = element_rect(color = "blue"))
Abaixo, seguem os argumentos do tipo rect.
theme(
rect,
     legend.background,
     legend.key,
     legend.box.background,
     panel.background,
     panel.border,
     plot.background,
     strip.background,
        strip.background.x,
        strip.background.y)
Por fim, temos a função element_blank(), que pode ser utilizada pelos argumentos de todos os tipos com o propósito de "apagar" os elementos de interesse.
ggplot(economics, aes(x = date, y = pce))+
geom_line(size = .8, colour = "darkblue")+
theme(text = element_blank(),
line = element_blank(),
rect = element_blank())

É possível que seja criado um tema padrão, que pode ser salvo dentro de um objeto com a finalidade de ser reutilizado de forma rápida ao longo do código.

theme_economics <- theme(text = element_text(family = "sans", size = 14),
rect = element_blank(),
panel.grid = element_blank(),
title = element_text(color = "darkblue"),
axis.line = element_line(color = "black"))
Por fim, reutilizamos
ggplot(economics, aes(x = date, y = pce))+
geom_line(size = .8, colour = "darkblue")+
theme_economics

Viu como é fácil criar o próprio tema e sempre poder reutilizado? Caso queira se aprofundar em visualização de dados no R utilizando o pacote {ggplot2}, veja nosso Curso de gráficos com ggplot2.

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.
________________________

Hackeando o R: 5 truques do Rmarkdown

By | Hackeando o R

Quando o assunto é criar documentos, estamos todos acostumados a realizar através de processadores de textos famosos como Word ou LibreOffice Writer. Para quem é da academia, talvez já tenha similaridade com outro tipo, tal como LaTex. Apesar disso, quando se entra no mundo do R, obviamente o trabalho fica muito mais fácil, e reportar os resultados utilizando esses processadores não se torna mais conveniente. Para tanto foi criado a ferramenta Rmarkdown, que facilita a produção de relatório no R. No Hackeando o R de hoje ensinaremos valiosos truques no mundo do Rmarkdown.

Para aprofundamento e detalhes confira o pacote de Cursos de Visualização de Dados no R.

Mostrar as imagens no console

Quando estamos criar um documento em Rmarkdown, estamos utilizando os códigos em chunks, que se definem por blocos de códigos que se completam quando realizamos o knit do documento. Utilizando os chunks, os resultados aparecem abaixo do próprio, dentro do script do R. Muitas vezes não é preferível que isso aconteça.

Para realizar a mudança, podemos seguir dois métodos. O primeiro pode ser mudando as configurações direto das configurações do Rstudio. Vá em Tools > Global Options > R markdown e desselecione a caixa "Show output inline for all R Markdown documents".

 

O segundo método consiste em colocar dentro do YAML o seguinte código: editor_options: chunk_output_type: console

 

Diminuir tamanho da fonte

Se a linha do seu código for muito grande, é provável que ele não caiba dentro do chunk no PDF, dessa forma, pode atrapalhar o relatório.

Um método para resolver este problema é configurando cada chunk com a opção size = "tiny".

 

Para facilitar o trabalho, é possível configurar globalmente no relatório essa opção definindo no começo do arquivo o seguinte código:

knitr::opts_chunk$set(size = "tiny")

 

Salvar imagens automaticamente

Muitas vezes cria-se relatórios Rmarkdown em PDF cheio de gráficos e tabelas, mas as vezes é possível se encontrar na situação de exportar essas imagens geradas pelo Rmarkdown individualmente para outros lugares. Para a felicidades de todos, o Rmarkdown possui uma configuração que cria uma pasta contendo todas as imagens geradas dentro de uma pasta.

A primeira forma pode ser mudando as configurações do YAML, utilizando o código keep_md: yes. Será salvo os arquivos de gráficos e tabelas individualmente.

 

Para caso queira que seja salvo em formato de imagem, como jpg ou png, pode-se utilizar dentro da configuração de cada chunk o código dev = "png". Para caso queira os dois formato, utiliza-se dev = c("png", "jpg").

Da mesma forma que a configuração do tamanho da fonte do chunk, é útil configurar para todo o relatório. É possível utilizando:


knitr::opts_chunk$set(dev = "png", # Salva como png
dpi = 300, # Configura a qualidade
echo = TRUE, # Mostra o código
cache = TRUE) # Cria o cache

 

Utilizando o Rstudio visual editor

Para quem está começando no Rmarkdown, ou não tem familiaridade com qualquer outro tipo de criador de documentos do tipo, e ainda possui uma dificuldade de escrever e imaginar o que será retornado no documento final, o Rstudio facilita disponibilizando o Visual Editor. Para acessá-lo, é necessário clicar no compasso no lado superior direito.

Pular páginas

É possível também pular páginas manualmente quando necessário no Rmarkdown. É viável de utilizar quando queira deixar o mais bem formatado as páginas possível. Esse comando é oriundo do LaTeX, mas o Rmarkdown reconhece o código. Para pular uma página deve-se utilizar

\newpage

fora do chunk.

Considerações

Elencamos apenas 5 dicas que podem ajudar quem está começando no mundo do Rmarkdown, mas que são valiosas. As possibilidades de configurações são enormes, sendo difícil colocar em apenas um post. Para quem deseja se aprofundar estaremos lançando nosso pacote de cursos de Visualização de dados no R, em que é oferecido o curso sobre Produção de Relatórios em Rmarkdown.

________________________

(*) Para aprofundamento e detalhes confira o pacote de Cursos de Visualização de Dados no R.

Receba diretamente em seu e-mail gratuitamente nossas promoções especiais
e conteúdos exclusivos sobre Análise de Dados!

Assinar Gratuitamente
{"cart_token":"","hash":"","cart_data":""}