Tag

rmarkdown Archives - Análise Macro

Criando apresentações com o {xaringan}

By | Data Science

O pacote {xaringan} no R permite criar slides "ninja", através de layouts já prontos para utilização, opções de gráficos e tabelas interativos, integração com LaTeX e formatação precisa. Por usar o R Markdown, você pode até mesmo automatizar os seus slides! Se você se cansou de sofrer criando slides no PowerPoint, dê uma chance ao {xaringan} e confira este breve tutorial.

O pacote {xaringan}

Fonte: xaringan package

Algumas das principais características do pacote:

  • Possibilita criar slides "ninjas" através do R Markdown;
  • Utiliza JavaScript e CSS internamente;
  • É altamente customizável e possui extensões;
  • Gera slides no formato HML com interatividade;
  • É possível converter o HTML para PDF (estático);
  • É um documento reprodutível e amplamente utilizado no R.

Criando uma apresentação {xaringan}

Para criar seu primeiro slide com o layout básico do {xaringan}, siga esses passos:

  1. Abra o RStudio e instale o pacote: install.packages("xaringan")
  2. Navegue por File > New File > R Markdown > From Template > Ninja Presentation {xaringan} > OK  e salve o arquivo .Rmd gerado
  3. Compile o documento usando o botão Knit (talvez você também precise instalar os pacotes DT e leaflet)
  4. Visualize o resultado na janela do RStudio ou abrindo o arquivo HTML gerado no seu navegador

E pronto! Com estes simples passos você já terá uma estrutura de slides pronta para trabalhar. Sugerimos que navegue pelos slides que são gerados por padrão no layout básico para conferir previamente os recursos e possibilidades disponíveis.

Criando e personalizando slides

A partir do layout básico é possível ter uma noção do funcionamento e sintaxe do pacote {xaringan}, mas vamos resumir aqui o principal que você precisa saber e algumas dicas que passamos no curso de Relatórios em R Markdown:

Dica 1: o conteúdo dos slides começam onde o YAML (cabeçalho) termina. Use cabeçalhos Markdown (#) para gerar o título do slide e crie novos slides com 3 hífens --- sequenciais em uma linha. Veja o exemplo:

 

Dica 2: Para criar um slide de destaque, com o fundo em cor de contraste, utilize a classe inverse  logo abaixo dos hífens de criação de novo slide. Opcionalmente você pode alinhar horizontalmente o conteúdo do slide ao centro com center e, verticalmente, ao meio com middle.

Dica 3: Os slides também podem ser configurados com um layout diferente via outras classes. Para criar um slide com conteúdo de "destaque" pode ser útil uma barra lateral à esquerda com largura limitada e o restante à direita. Para tal use as classes .left-column[] .right-column[], por exemplo:

 

Saiba mais

Para saber mais e se aprofundar no assunto, confira os cursos aplicados de R e Python da Análise Macro disponíveis neste outono, especialmente o curso de Produção de Relatórios em R Markdown.

 

Hackeando o R: Produzindo Relatórios Automáticos no R

By | Hackeando o R

Um dos maiores benefícios da linguagem em R está na facilidade do trabalho com análise de dados, sendo uma das etapas mais importantes no trabalho com dados contida na visualização e comunicação dos resultados. A linguagem R facilita também esse trabalho, utilizando o Rmarkdown para criar apresentações a partir do código e que tenha diversos formatos: PDF, HTML, Word e entre outros. No Hackeando o R de hoje, iremos aprender a criar relatórios automáticos no R, com base no conhecimento introdutório do nosso curso de Produção de Relatórios no R.

A maneira mais comum de criar um relatório no R é utilizando a ferramenta Rmarkdown. Para utilizada é importante que se tenha instalado o Rstudio, o pacote {rmarkdown} e também, para caso haja a criação de documentos PDF, um distribuidor de LaTeX. Para o caso, pode-se utilizar o tinytex, sendo sua instalação facilitada no R utilizando os seguintes código.


# Instala o pacote tinytex

install.packages("tinytex")

# Instala o distribuidor no computado

tinytex::install_tinytex()

Após isso, podemos criar documentos PDF com o Rstudio. Para a criação, cria-se um documento em Rmarkdown e configuramos o YAML e os chunks do código. Para criar o documento, vá em File > New File > R markdown.

Aparecerá uma tela para escolher o output do documento, como queremos um documento em PDF, selecionamos essa opção.

 

Temos a opção de criar relatório automáticos a partir de um relatório customizados, no qual ensinamos a como criar nesse post.

Criamos nosso código com base em um Relatório automático do IPCA-15.

Para se aprofundar no mundo do Rmarkdown, veja nosso Curso de Produção de Relatórios em Rmarkdown, e caso queira como coletar, tratar e visualizar dados sobre o IPCA-15, veja nosso Curso de Análise de Conjuntura.


---
title: "IPCA-15"
output: pdf_document
---

# Configurações dos chunks
knitr::opts_chunk$set(
echo = FALSE, # não mostra o código
eval = TRUE, # executar o código
fig.cap = "", # título do gráfico
results = "asis", # formato de renderização de texto
fig.width = 8, # largura do gráfico
fig.height = 4, # altura do gráfico
fig.align = "center", # alinhamento horizontal do gráfico
out.width = "100%", # redimensionamento do gráfico (aumentar/diminuir em %)
warning = FALSE, # exibir avisos do console
message = FALSE, # exibir mensagens do console
size = "tiny" # tamanho da fonte
)

# Carrega os pacotes

library(tidyverse)
library(sidrar)
library(scales)
library(ggrepel)
library(png)
library(grid)
library(forecast)
library(xts)
library(reshape2)
library(RcppRoll)

 

 

</pre>
# Cria a função para calcular o IPCA 15 acumulado em 12 meses

acum_p <- function(data, n){

factor <- (1+(data/100))

prod <- RcppRoll::roll_prodr(factor, n = n)

final <- (prod-1)*100

return(final)

}

# Cria um vetor de cores para utilizar no gráfico dos grupos do IPCA 15

colours <- c("#428953", "#CE2929", "#A3DD57", "#77E599", "#5675D6",
"#65ECEF", "#FF8B07", "#D0B100", "#636363")
<pre>

 

# IPCA-15

### Variação Mensal</pre></pre>
# Coleta os dados mensais do IPCA-15 através do SIDRA

ipca15 <- get_sidra(api = "/t/3065/n1/all/v/355/p/all/d/v355%202") %>%
mutate(date = parse_date(`Mês (Código)`, format = "%Y%m")) %>%
select(date, Valor) %>%
rename(ipca15_mensal = "Valor") %>%
as_tibble()

# Gráfico da variação mensal do IPCA-15

ggplot(data = ipca15, aes(x = date, y = ipca15_mensal))+
geom_line(size = .8, colour = "darkblue")+
geom_hline(yintercept = 0, colour = "red", linetype = 'dashed')+
labs(title = "Inflação Mensal IPCA-15",
caption = "Fonte: analisemacro.com.br com dados do IBGE",
x = "",
y = "")+
scale_x_date(breaks = date_breaks('1 year'),
labels = date_format("%Y"))+
theme(axis.text.x = element_text(angle=45,
hjust=1),
panel.background = element_rect(fill='white',
colour='white'))
<pre>

### Variação Acumulada em 12 meses</pre>
# Calcula a variação acumulada em 12 meses

ipca15 <- ipca15 %>%
mutate(ipca15_anual = acum_p(ipca15_mensal, 12))

# Cria os valores da meta de inflação

meta <- c(rep(4.5, 139), rep(4.25, 12),
rep(4, 12), rep(3.75, 12), rep(3.5, 12), rep(3.25, 12))

meta_max <- c(rep(4.5+2, 115), meta[-(1:115)]+1.5)
meta_min <- c(rep(4.5-2, 115), meta[-(1:115)]-1.5)

metas <- tibble(lim_sup=meta_max, meta=meta,
lim_inf=meta_min,
date = seq(as.Date('2007-06-01'), as.Date('2023-12-01'),
by='1 month'))

# Junta em tibble os dados da meta e do IPCA-15

ipca15 <- inner_join(ipca15, metas, by='date')

# Plota a variação acumulada em 12 meses do IPCA-15 em conjunto com as metas

ggplot(ipca15, aes(x = date, y = ipca15_anual))+
geom_ribbon(aes(ymin=lim_inf, ymax=lim_sup),
colour='grey70', alpha=0.2)+
geom_line(aes(y=ipca15_anual, colour='Inflação 12 meses'), size=.8)+
geom_line(aes(y=meta, colour='Meta de Inflação'), size=.8)+
scale_colour_manual('',
values=c('Inflação 12 meses'='darkblue',
'Meta de Inflação'='red'))+
labs(title='Inflação medida pelo IPCA-15 acumulado em 12 meses',
caption='Fonte: analisemacro.com.br com dados do IBGE.',
x = "",
y = "")+
scale_x_date(breaks = date_breaks("1 year"),
labels = date_format("%Y"))+
theme(axis.text.x=element_text(angle=45, hjust=1),
legend.position = c(.2,.85),
legend.key.size = unit(0.2, "cm"),
plot.title = element_text(size=12, face='bold'),
panel.background = element_rect(fill='white',
colour='white'))+
geom_label_repel(label=round(tail(ipca15$ipca15_anual, 1) ,2),
nudge_y = 2,
nudge_x = -2,
data = tail(ipca15, 1),
color = 'bl
<pre>

 

 


### Sazonalidade

É possível visualizar a sazonalidade do IPCA-15 e ver qual mês tende a possuir as menores ou maiores variações.</pre>
# Trata os dados do IPCA 15</pre>
# Trata os dados do IPCA 15

ipca15ts <- ts(ipca15$ipca15_mensal, start = c(2000,05), freq = 12)

# Visualiza a sazonalidade

ggsubseriesplot(ipca15ts)+
theme(panel.background = element_rect(fill='white',
colour='white'))+
labs(x = "",
y = "",
title = "Sazonalidade - IPCA-15",
caption = "Fonte: analisemacro.com.br com dados do IBGE")
<pre>

 

 

Criado o código nos chunks, cria-se o relatório utilizando o botão knit no Rstudio. O resultado aparecerá em um PDF na pasta em que utilizou como trabalho no Rstudio.

___________________

O processo envolve muito mais possibilidades de criação, além também da customização. Você pode aprender a criar Relatórios mais completos a partir do nosso Curso de Produção de Relatórios em Rmarkdown.

___________________

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.

_________________________________________

 

Criando uma dashboard de análise da inflação

By | Data Science

Quando o objetivo é analisar dados, é necessário utilizar as ferramentas adequadas para tornar os dados brutos em informação que seja útil. Para tal objetivo, uma dashboard pode ser o formato mais conveniente, dado seu poder de customização, compartilhamento e automatização. Nesse contexto, exploramos como exemplo a construção de uma dashboard simples aplicada à análise dos dados de inflação do Brasil, fazendo uso dos principais pacotes do R.

Visão geral

O objetivo geral é construir uma dashboard dinâmica onde seja possível analisar o comportamento histórico dos principais indicadores para acompanhamento de conjuntura do tema inflação, tais como: IPCA, IGP-M, INPC, etc. Além disso, para dar mais autonomia ao usuário final da dashboard, a mesma contará com opções de filtros de datas, indicadores, medidas, etc., tornando possível uma análise mais customizável.

Em resumo, a dashboard terá a seguinte aparência:

Você também pode conferir o resultado completo neste link.

Pacotes e framework

Para construir a dashboard você precisará dos seguintes pacotes disponíveis em sua instalação de R:


# Carregar pacotes
library(shiny)
library(ggplot2)
library(readr)
library(lubridate)
library(dplyr)
library(stringr)
library(forcats)
library(tidyr)
library(scales)
library(ggtext)
library(tsibble)
library(fabletools)
library(feasts)
library(Hmisc)
library(rmarkdown)
library(flexdashboard)

Optou-se por utilizar o framework dos pacotes shiny e flexdashboard, que oferecem uma sistemática de programação reativa e sintaxe simples e amigável, respectivamente, tornando o processo de criação de dashboards dinâmicas mais fácil. Além disso, a dashboard foi hospedada no serviço shinyapps.io e automatizada usando o GitHub Actions (confira neste link um tutorial de uso).

Para aprofundamento e detalhes confira o Curso de Análise de Conjuntura usando o R.

Criando a dashboard

O primeiro passo é criar um projeto do RStudio, para isso use usethis::create_project("nome_do_projeto").

Em seguida, criamos o arquivo principal da dashboard utilizando o template básico oferecido pelo pacote flexdashboard: basta navegar pelos menus File > New File > R Markdown > From Template > Flex Dashboard {flexdashboard} > OK e salvar o arquivo .Rmd na raiz do projeto.

No arquivo editamos os metadados com as definições desejadas para a dashboard, conforme abaixo:


---
title: "Diagnóstico da Inflação"
output:
flexdashboard::flex_dashboard:
orientation: rows
source_code: NULL
social: menu
navbar:
- { icon: "fa-github", href: "https://ENDEREÇO_DO_SITE/", align: right }
- { icon: "fa-linkedin", href: "https://ENDEREÇO_DO_SITE/", align: right }
- { icon: "fa-at", href: "mailto:MEU@EMAIL.COM", align: right }
runtime: shiny
---

Agora podemos começar a trabalhar nos dados e elementos visuais da dashboard. No primeiro chunk do documento (global) especificamos os pacotes, carregamos os dados e definimos objetos úteis a serem utilizados nos gráficos.

Os dados ficam salvos em uma pasta chamada "data" e são atualizados automaticamente por um script independente, visando diminuir dependências e tempo de carregamento da dashboard. Neste link você pode baixar os dados para poder reproduzir o exemplo.


# Carregar pacotes
library(shiny)
library(ggplot2)
library(readr)
library(lubridate)
library(dplyr)
library(stringr)
library(forcats)
library(tidyr)
library(scales)
library(ggtext)
library(tsibble)
library(fabletools)
library(feasts)
library(Hmisc)

# Carregar dados públicos previamente importados via pacotes
tbl_inflation <- readr::read_rds("data/tbl_inflation.rds")

# Objetos úteis na dashboard
colors <- c(
blue = "#282f6b",
red = "#b22200",
yellow = "#eace3f",
green = "#224f20",
purple = "#5f487c",
black = "black"
)

Em seguida, criamos uma linha usando cabeçalho Markdown de nível dois (------------------) e determinamos que esse elemento seja a sidebar da dashboard. Essa barra lateral é, usualmente, onde são exibidos os filtros e opções de interatividade, além de poder servir de espaço para textos informativos. No nosso exemplo, colocamos um texto breve e definimos, conforme chunk abaixo, os inputs que criamos através do shiny para aplicar filtros e manipulações de dados:


# Cria input do tipo "lista de caixas de seleção" com índices de preços como opções
# Objetivo: usuário pode escolher quaL indicador será exibido no gráfico
shiny::selectInput(
inputId = "variavel",
label = shiny::strong("Indicador:"),
choices = unique(tbl_inflation$variable),
selected = unique(tbl_inflation$variable)[1],
multiple = FALSE
)

# Cria input do tipo "calendário" de seleção de data de início e fim
# Objetivo: usar as datas selecionadas para filtrar amostra de dados utilizada no gráfico/cálculos
shiny::dateRangeInput(
inputId = "data",
label = shiny::strong("Data inicial e final:"),
min = min(tbl_inflation$date),
max = max(tbl_inflation$date),
start = min(tbl_inflation$date),
end = max(tbl_inflation$date),
language = "pt-BR",
separator = " - ",
format = "mm/yyyy"
)

# Cria input do tipo "campo numérico" para entrada de um ano para comparação
# Objetivo: comparar medidas (mediana e IQR) com dados observados referente ao ano
shiny::numericInput(
inputId = "ano",
label = shiny::strong("Comparar com o ano:"),
value = lubridate::year(max(tbl_inflation$date)),
min = lubridate::year(min(tbl_inflation$date)),
max = lubridate::year(max(tbl_inflation$date)),
step = 1
)

# Tratamento para atualizar o ano pré-selecionado no input$ano em resposta a uma
# mudança da amostra de dados definida pelo usuário no input$data:
# o objetivo é que quando o usuário diminui a amostra de dados, o ano de comparação
# selecionado não fique fora dessa nova amostra e seja atualizado para um novo
# valor o mais próximo possível dos valores extremos (anos) da nova amostra
shiny::observeEvent(
eventExpr = input$data, # observa mudanças do usuário na amostra de dados
handlerExpr = { # expressões que serão executadas quando input$data mudar

data_inicial <- lubridate::year(input$data[1])
data_final <- lubridate::year(input$data[2])

shiny::updateNumericInput( # atualiza o valor de input$ano quando a mudança é detectada
inputId = "ano",
value = if(!input$ano %in% data_inicial:data_final & data_inicial > input$ano){
data_inicial
} else
if(!input$ano %in% data_inicial:data_final & data_final < input$ano){
data_final
} else input$ano,
min = data_inicial,
max = data_final,
step = 1
)

}
)

# Cria input do tipo "lista de caixas de seleção" com componentes para filtragem
shiny::checkboxGroupInput(
inputId = "componentes",
label = shiny::strong("Componentes:"),
choices = c("% a.m.", "Tendência", "Sazonalidade", "Média"),
selected = c("% a.m.", "Tendência", "Média")
)

Uma vez definidos os inputs, passamos à construção dos outputs que serão dois gráficos neste caso. Para tal, criamos mais duas linhas: a primeira responsável por criar o gráfico dinâmico que compara a sazonalidade dos dados históricos com um determinado ano, especificado pelo usuário; e a segunda é responsável pelo gráfico dinâmico que mostra alguns componentes da série escolhida.

Veja, por exemplo, que o primeiro gráfico é afetado por mudanças no input referente ao filtro de datas, definição de ano de comparação e o indicador escolhido, sendo assim o script exige essas entradas/definições, utiliza esses valores armazenados para tratamento e cálculos nos dados, e, por fim, gera o gráfico de ggplot2 dinamicamente:


# Gerar gráfico dinâmico (se atualiza conforme o input da sidebar)
shiny::renderPlot({

# Use a função req para exigir que os valores do inputs sejam informados pelo usuário,
# isso evita que o R execute o script "ansiosamente"
shiny::req(
input$data,
input$ano %in% lubridate::year(input$data[1]):lubridate::year(input$data[2]),
input$variavel
)


# Valores dos inputs salvos em objetos auxiliar, por conveniência
data_inicial <- lubridate::floor_date(input$data[1])
data_final <- lubridate::floor_date(input$data[2])
data_compara <- input$ano
indicador <- input$variavel


# Script para calcular padrão sazonal mensal conforme inputs do usuário: mediana e IQR
seas_pattern <- tbl_inflation %>%
dplyr::group_by(
variable,
date_m = lubridate::month(.data$date, label = TRUE, locale = "pt_BR.utf8") %>%
stringr::str_to_sentence(locale = "br") %>%
forcats::as_factor()
) %>%
dplyr::filter(date >= data_inicial & date <= data_final) %>%
dplyr::summarise(
iqr = ggplot2::median_hilow(mom, conf.int = 0.5),
.groups = "drop"
) %>%
tidyr::unnest(cols = iqr) %>%
dplyr::rename("median" = "y", "date" = "date_m") %>%
dplyr::left_join(
tbl_inflation %>%
dplyr::filter(
date >= data_inicial & date <= data_final,
lubridate::year(.data$date) == data_compara
) %>%
dplyr::mutate(
date = lubridate::month(.data$date, label = TRUE, locale = "pt_BR.utf8") %>%
stringr::str_to_sentence(locale = "br") %>%
forcats::as_factor()
),
by = c("variable", "date")
) %>%
tidyr::pivot_longer(
cols = -c(variable, date, ymin, ymax),
names_to = "measure",
values_to = "value"
) %>%
dplyr::mutate(
measure = dplyr::recode(
measure,
"median" = "Mediana",
"mom" = as.character(data_compara)
)
) %>%
dplyr::filter(variable == indicador)


# Gerar gráfico dinâmico
seas_pattern %>%
ggplot2::ggplot() +
ggplot2::aes(x = date, y = value, color = measure, shape = measure, group = measure) +
ggplot2::geom_hline(yintercept = 0) +
ggplot2::geom_ribbon(
ggplot2::aes(
ymin = ymin,
ymax = ymax,
fill = "IQR (CI = 0,5)"
),
alpha = 0.2,
color = NA
) +
ggplot2::geom_line(size = 1.2) +
ggplot2::geom_point(size = 3) +
ggplot2::scale_color_manual(
NULL,
values = c(unname(colors["red"]), unname(colors["black"])),
guide = ggplot2::guide_legend(
override.aes = list(
shape = c(16, NA)
)
)
) +
ggplot2::scale_fill_manual(
NULL,
values = c("IQR (CI = 0,5)" = unname(colors["black"]))
) +
ggplot2::scale_shape_manual(
NULL,
values = c(16, NA)
) +
ggplot2::scale_y_continuous(
breaks = scales::extended_breaks(n = 6),
labels = scales::label_number(decimal.mark = ",", accuracy = 0.01),
minor_breaks = NULL
) +
ggplot2::labs(
title = paste0("**", indicador, "**: padrão sazonal"),
subtitle = paste0(
"% a.m., ",
paste0(
lubridate::year(data_inicial),
"m",
ifelse(
lubridate::month(data_inicial) < 10,
paste0("0", lubridate::month(data_inicial)),
lubridate::month(data_inicial)
),
"-",
lubridate::year(data_final),
"m",
ifelse(
lubridate::month(data_final) < 10,
paste0("0", lubridate::month(data_final)),
lubridate::month(data_final)
)
)
),
x = NULL,
y = NULL,
caption = "**Dados:** FGV e IBGE | **Elaboração:** Fernando da Silva"
) +
ggplot2::theme_light() +
ggplot2::theme(
legend.position = "bottom",
legend.key = ggplot2::element_blank(),
legend.key.width = ggplot2::unit(1, "cm"),
legend.key.height = ggplot2::unit(0.5, "cm"),
legend.text = ggplot2::element_text(size = 12),
plot.title = ggtext::element_markdown(size = 30, colour = colors["blue"]),
plot.subtitle = ggplot2::element_text(size = 16),
plot.caption = ggtext::element_markdown(size = 12),
axis.text = ggplot2::element_text(size = 12),
strip.background = ggplot2::element_blank(),
strip.text = ggplot2::element_text(size = 12, face = "bold", colour = colors["black"])
)

})

Após gerar os elementos visuais, utilize o botão Run Document no RStudio para visualizar o resultado, ou seja, a dashboard propriamente dita.

Os últimos passos envolvem fazer o deploy da dashboard e automatizar a coleta inicial de dados. Consulte as referências inicias para orientação sobre o assunto.

___________________

(*) Para aprofundamento e detalhes confira o Curso de Análise de Conjuntura usando o R.

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