Tag

dicas de R Archives - Análise Macro

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

Hackeando o R: analisando modelos com o tidymodels

By | Hackeando o R

No Hackeando o R de hoje, vamos continuar nossa exposição do pacote tidymodels, a partir daonde paramos no nosso post de semana passada. Para resumir, o método básico, chamado de workflow, depende apenas de uma receita, que descreve o processamento de dados, e um parsnip, que descreve o modelo que queremos utilizar e seus parâmetros.

Após realizarmos os passos acima, podemos tentar verificar a qualidade do nosso modelo através da reamostragem. Vamos começar com um exemplo da qualidade de imagens de células, do pacote modeldata. Os dados possuem uma classificação, que indica se a observação é boa ou ruim para o objetivo final do estudo. Como a amostra total é muito grande para ser classificada manualmente, nosso trabalho é montar um modelo que preveja corretamente a classificação a partir de variáveis mensuráveis, dada a amostra.

library(modeldata)
library(tidymodels)

data(cells)

Para iniciarmos, devemos separar nossa amostra em uma partição de treinamento e teste. Isso é feito facilmente pela função initial_split(). Note que removemos a coluna case, que não é interessante para nós, diretamente dentro da função, com linguagem do tidyverse. Ademais, o argumento strata é importante: como temos muito mais dados ruins do que bons, uma partição aleatória poderia conter dados ruins demais no treino ou no teste, dificultando a estimação. Ao utilizar o argumento, garantimos que ambas as partes possuam proporções 'razoáveis' de cada classe.

set.seed(123)

cell_split <- initial_split(cells %>% select(-case),
strata = class)

cell_train <- training(cell_split)
cell_test <- testing(cell_split)

Para a modelagem, faremos um modelo de random forest. Não entraremos nos detalhes de seu funcionamento, pois já falamos sobre esse modelo em um post mais antigo. Dentro do ambiente do tidymodels, podemos facilmente criar a random forest usando o pacote ranger:

rf_mod =
rand_forest(trees = 1000) %>%
set_engine("ranger") %>%
set_mode("classification")

rf_fit =
rf_mod %>%
fit(class ~ ., data = cell_train)

Após treinar o modelo, podemos testar ele com as funções do pacote yardstick. Abaixo, calculamos a acurácia das previsões:

rf_testing_pred =
predict(rf_fit, cell_test) %>%
bind_cols(predict(rf_fit, cell_test, type = "prob")) %>%
bind_cols(cell_test %>% select(class))

rf_testing_pred %>%
accuracy(truth = class, .pred_class)

Como podemos ver, o modelo é razoável, porém pode melhorar. Para isso, vamos utilizar a reamostragem, fazendo validação cruzada. O método é simples: criamos os folds, geramos um novo workflow, e o informamos que é para fazer o fit sobre cada um dos folds.

folds = vfold_cv(cell_train, v = 10)

rf_wf =
workflow() %>%
add_model(rf_mod) %>%
add_formula(class ~ .)

rf_fit_rs =
rf_wf %>%
fit_resamples(folds)

Após isso, podemos utilizar a função collect_metrics() para verificar o resultado dos modelos sobre cada fold. O resultado mostra que nosso teste inicial acaba sendo sim um bom previsor.


collect_metrics(rf_fit_rs)

 .metric .estimator mean n std_err .config 
<chr> <chr> <dbl> <int> <dbl> <chr> 
1 accuracy binary 0.833 10 0.00971 Preprocessor1_Model1
2 roc_auc binary 0.906 10 0.00901 Preprocessor1_Model1

________________________
(*) Para entender mais sobre a linguagem R e suas ferramentas, confira nosso Curso de Introdução ao R para análise de dados.

Hackeando o R: Introdução ao tidymodels

By | Hackeando o R

No Hackeando o R de hoje, vamos falar sobre o pacote tidymodels, que tem como objetivo inserir dentro do tidyverse a modelagem estatística. É muito comum aprendermos a fazer a extração e a manipulação de dados utilizando o tidyverse, e então rodar modelos com funções de outras fontes, para voltar ao tidyverse para fazer a visualização dos resultados utilizando o ggplot2. Isso é de certa forma ineficiente, pois precisamos cuidar para que as funções sejam compatíveis e que a própria escrita do código seja legível para outras pessoas. Ao invés de se preocupar com isso, vamos mostrar como fazer os modelos diretamente no tidyverse, podendo assim maanter a consistência de código e facilitando a integração.

Primeiramente, vamos carregar alguns pacotes utilizados:

library(tidymodels)
library(nycflights13)

Iremos trabalhar com os dados de voos do pacote nycflights13data. Antes de introduzirmos elementos específicos da modelagem, vamos manipular os dados:

set.seed(123)

dados =
flights %>%
mutate(
arr_delay = ifelse(arr_delay >= 30, "atraso", "sem_atraso"),
arr_delay = factor(arr_delay),
date = lubridate::as_date(time_hour)
) %>%
inner_join(weather, by = c("origin", "time_hour")) %>%
select(dep_time, flight, origin, dest, air_time, distance,
carrier, date, arr_delay, time_hour) %>%
na.omit() %>%
mutate(across(where(is.character), as.factor))

A ideia de utilizar o tidymodels é implementar um workflow. Essencialmente, criamos componentes que são inteiramente integrados no tidyverse, e os juntamos dentro desse tipo de objeto, de modo que qualquer mudança nos dados, na metodologia de estimação, ou no modelo em si, é facilitada pelo fato de que conseguimos observar claramente cada módulo do modelo. No post de hoje, trabalharemos com um modelo simples, logo teremos duas partes: uma recipe e um model.

Para começar, vamos criar a recipe. Esse objeto engloba todo o pré-processamento dos dados, e algumas outras funções. Inicialmente, adicionamos a ela o modelo em si (em notação de modelo) e os dados que iremos utilizar. Após isso, nós podemos utilizar a função update_role() para dar um papel diferente a algumas variáveis. No caso, o modelo inicial considera todas as colunas como previsores de arr_delay, porém queremos que flight e time_hour não sejam previsores, e sim apenas indicadores de cada observação.

receita_flights =
recipe(arr_delay ~ ., data = treino) %>%
update_role(flight, time_hour, new_role = "ID")

A partir daí, podemos fazer transformações facilmente nos dados que melhoram nosso dataset. Vamos adicionar colunas de dia da semana e mês dos voos com a função step_date(), e adicionar uma coluna para feriados nos EUA.


receita_flights = receita_flights %>%
step_date(date, features = c("dow", "month")) %>% 
step_holiday(date, 
holidays = timeDate::listHolidays("US"), 
keep_original_cols = FALSE) %>%
step_dummy(all_nominal_predictors()) %>%
step_zv(all_predictors())

Note que há uma outra função acima, chamada de step_dummy(). Essencialmente, ela transforma variáveis categóricas em dummies, para podermos fazer a regressão. Em outros métodos o R faz sozinho essa transformação, porém aqui devemos fazer ela manualmente pois há modelos que não dependem de valores numéricos, logo é melhor manter a estrutura original dos dados caso necessário. Para finalizar, adicionamos a step_zv, que elimina valores que ocorrem uma única vez (que podem causar problemas pois ou só estão no treino, ou só estão no teste).

Após criar a recipe, gerar um modelo é muito simples. Iniciamos com o tipo de regressão que queremos, e adicionamos a engine que queremos usar para calculá-lo. Abaixo, geramos uma regressão logística usando o glm:


modelo = 
logistic_reg() %>% 
set_engine("glm")

Após isso, basta gerar nosso workflow. Abaixo, criamos ele, adicionamos a recipe, o modelo, e então treinamos ele com dados de treino. Finalizamos extraindo o resultado com a extract_fit_parsnip().


workflow() %>% 
add_model(modelo) %>% 
add_recipe(receita_flights) %>%
fit(data = treino) %>%
extract_fit_parsnip() %>% 
tidy()

 term estimate std.error statistic p.value
<chr> <dbl> <dbl> <dbl> <dbl>
1 (Intercept) 5.99 2.74 2.19 2.88e- 2
2 dep_time -0.00167 0.0000141 -118. 0 
3 air_time -0.0441 0.000562 -78.5 0 
4 distance 0.00565 0.00151 3.75 1.80e- 4
5 date_USChristmasDay 1.24 0.168 7.36 1.78e-13
6 date_USColumbusDay 0.801 0.179 4.48 7.40e- 6
7 date_USCPulaskisBirthday 0.836 0.140 5.97 2.31e- 9
8 date_USDecorationMemorialDay 0.436 0.113 3.87 1.08e- 4
9 date_USElectionDay 0.792 0.175 4.52 6.15e- 6
10 date_USGoodFriday 1.36 0.173 7.85 4.30e-15

________________________
(*) Para entender mais sobre a linguagem R e suas ferramentas, confira nosso Curso de Introdução ao R para análise de dados.

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

Assinar Gratuitamente