All Posts By

Fernando da Silva

Acessando microdados da PNAD Contínua no R

By | Data Science

Os microdados da Pesquisa Nacional por Amostra de Domicílios Contínua (PNADC), produzida pelo IBGE, possuem uma riqueza enorme de informação de um conjunto de indicadores relacionados à força de trabalho no país, constituindo um verdadeiro tesouro para economistas e cientistas sociais. Esse grande volume de dados exige, por consequência, o uso de ferramentas adequadas para o tratamento, análise, visualização e sua utilização em geral. Em suma, é necessário utilizar linguagens de programação para "colocar a mão" nesses dados e, neste exercício, mostraremos como fazer isso usando o R.

Para reproduzir o exercício a seguir você precisará dos seguintes pacotes:


library(PNADcIBGE) # CRAN v0.7.0
library(survey) # CRAN v4.0
library(convey) # CRAN v0.2.3
library(magrittr) # CRAN v2.0.1

1)  Importar microdados trimestrais  

Para começar o exercício, vamos importar os microdados para o environment do R usando o pacote PNADcIBGE - que foi desenvolvido pela própria equipe do IBGE. Os microdados trimestrais serão o alvo do nosso exemplo: apontamos na função get_pnadc o último período (ano/trimestre) disponível da pesquisa e, opcionalmente, as variáveis de interesse1.


# Importar online microdados do 3º trimestre de 2021
dados_pnadc <- get_pnadc(year = 2021, quarter = 3, vars = c("VD4020", "V2007"))

# Classe do objeto
class(dados_pnadc) # útil para análises de dados amostrais complexos

[1] "svyrep.design"

2)  Análise de dados

Após este simples comando de importação executado, os microdados da PNADC já estão disponíveis para fazermos uma análise. A função, inclusive, já configura o plano amostral internamente através do argumento design = TRUE - mas o usuário pode desabilitar para obter os dados brutos -, sendo assim podemos usar o pacote survey para obter, por exemplo, o total de homens e mulheres:


# Obter nº total de homens e mulheres
svytotal(x = ~V2007, design = dados_pnadc, na.rm = TRUE)

#                  total     SE
# V2007Homem   104020393 0.1207
# V2007Mulher  108787836 0.0998

Da mesma forma, e com comandos simples, o usuário pode estimar o índice de Gini a nível nacional:


# Estimar o índice de Gini
dados_pnadc %>%
convey_prep() %>%
svygini(formula = ~VD4020, na.rm = TRUE)

#           gini     SE
# VD4020 0.51625 0.0034

Diversas outras análise podem ser feitas, como esta publicada no blog da Análise Macro:

Saiba mais

Para saber mais confira os cursos aplicados de R e Python.


[1] Note que os microdados consomem espaço excepcionalmente grande na memória do computador, portanto, evite a importação sem nenhum tipo de filtro de variáveis.

 

Como criar defasagens de uma variável no R

By | Data Science

Análise de séries temporais frequentemente exige tratamentos e transformações dos dados, como a criação de defasagens (lag, no inglês) de uma variável. Podemos representar esse procedimento envolvendo o operador lag como:

Ou seja, quando aplicamos a defasagem em um elemento de yt o que obtemos é o valor anterior da série temporal.

No R este procedimento é bastante simples, sendo possível fazê-lo de mais de uma maneira diferente. Vamos a um exemplo prático!

Para reproduzir o exercício a seguir você precisará dos seguintes pacotes:


library(magrittr) # CRAN v2.0.1
library(dplyr) # CRAN v1.0.7
library(timetk) # CRAN v2.6.2
library(tsibbledata) # CRAN v0.2.0

Vamos usar a série temporal do crescimento anual do PIB brasileiro como exemplo. Esses dados estão disponíveis no pacote tsibbledata. Primeiro uma rápida visualização da série:


pib_br <- tsibbledata::global_economy %>%
dplyr::filter(Country == "Brazil") %>%
dplyr::select(Year, Growth)

pib_br %>%
timetk::plot_time_series(
.date_var = Year,
.value = Growth,
.title = "Brasil: crescimento anual do PIB",
.y_lab = "%",
.line_size = 2,
.smooth = FALSE,
.interactive = FALSE
)

O objeto que temos é do tipo data.frame com características de série temporal (tsibble), muito vantajoso para procedimentos de tratamento de dados usando tidyverse. Neste formato, para criar uma defasagem da variável podemos simplesmente adicionar uma coluna aplicando a função dplyr::lag na variável de interesse. Simples, não?


pib_br %>% dplyr::mutate(growth_lag1 = dplyr::lag(Growth))

Caso o usuário precise criar múltiplas defasagens de uma variável, não há problema. O pacote timetk possui a função tk_augment_lags() que facilita o trabalho, basta apontar uma sequência de lags a serem criados, por exemplo de 1 até 10:


pib_br %>% timetk::tk_augment_lags(Growth, .lags = 1:10)

 

Saiba mais:

Como reverter a primeira diferença de uma série temporal?

By | Data Science

 

Modelagem de séries temporais frequentemente exige a aplicação de transformações nas variáveis, tal como a bem conhecida primeira diferença. Formalmente, podemos descrever essa transformação como:

Ou seja, dado uma série temporal regularmente espaçada, subtraímos do valor em t o valor anterior (t-1), obtendo a série dita "na primeira diferença" ou "nas diferenças".

A mudança de nível da série geralmente contorna diversas características "não desejadas" pelo analista como tendência, sazonalidade, etc., mas dificulta a interpretação dos valores - especialmente quando pretende-se comunicá-los para públicos não técnicos. Para este objetivo é de grande utilidade saber como diferenciar uma série temporal e, sobretudo, também como reverter a transformação.

Para reverter a primeira diferença de uma série utilizamos a soma cumulativa, representada como:

Ou seja, no final teremos um vetor com a soma de cada valor em t com todos os anteriores, valores estes que neste caso podem representar a série na primeira diferença que se deseja reverter.

Exemplo no R

Para exemplificar, vamos aplicar um exercício simples no R com o objetivo de 1) tomar a primeira de uma série e 2) reverter a transformação para obter a série original.

Para esse exemplo você precisará dos seguintes pacotes:


library(magrittr) # CRAN v2.0.1
library(GetBCBData) # CRAN v0.6
library(dplyr) # CRAN v1.0.7
library(timetk) # CRAN v2.6.2
library(tsibble) # CRAN v1.0.1
library(tidyr) # CRAN v1.1.4

Utilizaremos uma série conhecidamente não estacionária: a taxa de câmbio (R$/US$). Primeiro, importamos a série diretamente do banco de dados do Banco Central (SGS/BCB) e tratamos os dados para obter um tibble:


dados <- GetBCBData::gbcbd_get_series(
id = 3696,
first.date = "2000-01-01",
use.memoise = FALSE
) %>%
dplyr::select("date" = "ref.date", "value") %>%
dplyr::as_tibble()
dados

Uma rápida visualização dos dados:


timetk::plot_time_series(
.data = dados,
.date_var = date,
.value = value,
.smooth = FALSE,
.title = "Taxa de câmbio (R$/US$)"
)

Para criar a série na primeira diferença usamos a função tsibble::difference1, com seus argumentos padrão:

dados %<>%
dplyr::mutate(value_diff = tsibble::difference(value))
dados

Quando a diferença é aplicada inevitavelmente perdemos uma observação (a primeira), sendo preenchida no objeto como um NA. Sendo assim, a reversão dessa série para o seu nível (valores originais) requer uma artimanha: devemos substituir o valor NA pelo valor original da série correspondente a esse período dos dados e, então, usar a função cumsum para calcular a soma cumulativa.
dados %<>%
dplyr::mutate(
value_diff = dplyr::if_else(is.na(value_diff), value, value_diff),
value_revert = cumsum(value_diff)
)
dados
Checando se a série revertida corresponde aos valores originais:
all.equal(dados$value_revert, dados$value)
# [1] TRUE

Os cálculos ocorreram conforme o esperado: a série original da taxa de câmbio importada do BCB é igual à série que aplicamos e revertemos a primeira diferença.

Simples, não?

Por fim, vale comparar visualmente o comportamento da série em nível e na diferença (primeiro gráfico):


dados %>%
dplyr::select(
"date",
"Nível" = "value",
"1ª diferença" = "value_diff",
"Série revertida" = "value_revert"
) %>%
tidyr::pivot_longer(
cols = -"date",
names_to = "variable"
) %>%
timetk::plot_time_series(
.date_var = date,
.value = value,
.facet_vars = variable,
.smooth = FALSE,
.title = "Taxa de câmbio (R$/US$)",
.interactive = FALSE
)

 


[1] Para um equivalente em base R veja ?diff.

Gerando previsões desagregadas de séries temporais

By | Data Science

Frequentemente, séries temporais podem ser desagregadas em vários atributos de interesse. Por exemplo1, o número total de veículos produzidos no país ao longo do tempo pode ser dividido em veículos comerciais leves, caminhões, ônibus, etc. Cada uma dessas categorias pode ainda ser desagregada em outros níveis, por regiões, por fabricante, etc., caracterizando o que pode ser chamado de "séries temporais hierárquicas".

Essa riqueza de informação e dados possibilita (e pode ser de interesse) gerar previsões desagregadas das séries, de modo que os pontos de previsão das séries desagregadas possam ser analisados individualmente e que, quando agregados de alguma forma, sejam coerentes com os valores agregados da série.

De modo geral, podemos representar o exemplo como:

Ou seja, para qualquer observação no tempo t, as observações no nível inferior da hierarquia serão agregadas para formar as observações da série acima.

Previsão hierárquica

Existem várias abordagens para gerar previsões hierárquicas com séries temporais, a mais comum e intuitiva é a bottom-up (de baixo para cima), onde primeiro geramos as previsões para cada série no nível inferior e, em seguida, somamos os pontos de previsão para obter previsões da série acima.

Por outro lado, a abordagem top-down (de cima para baixo) envolve primeiro a geração de previsões para a série agregada e, em seguida, desagregá-la na hierarquia utilizando proporções (geralmente baseadas na série histórica).

Ainda existem outras abordagens como a do Minimum Trace e suas variantes, sendo que cada uma tem seus prós e contras. Para se aprofundar no tema veja Forecasting: principles and practice de Hyndman, R.J., & Athanasopoulos, G. (2021), que apresenta detalhes sobre as abordagens disponíveis.

Exemplo: dados de produção da ANFAVEA

Mensalmente a ANFAVEA disponibiliza séries temporais da produção, licenciamento, exportação, etc. de veículos. Os dados são desagregados pelas categorias citadas acima e neste exemplo iremos explorar alguns métodos de gerar modelos de previsão para as séries de produção de veículos.

Primeiro, para reproduzir o código certifique-se de que tenha os seguintes pacotes em sua instalação do R:

# Carregar pacotes/dependências
library(magrittr)
library(GetBCBData)
library(dplyr)
library(tsibble)
library(fabletools)
library(ggplot2)
library(lubridate)
library(fable)

Para importar as séries podemos usar o banco de dados do Banco Central (BCB) através do pacote GetBCBData, bastando apontar os códigos de coleta obtidos diretamente no site da instituição.

raw_anfavea <- GetBCBData::gbcbd_get_series(
id = c(
"Total" = 1373,
"Comerciais leves" = 1374,
"Caminhões" = 1375,
"Ônibus" = 1376
),
first.date = "1993-01-01",
use.memoise = FALSE
)

Além disso fazemos o tratamento necessário para obter um objeto de classe tsibble, pois precisamos desse formato para a próxima etapa de modelagem e previsão:

anfavea <- raw_anfavea %>%
dplyr::select("date" = "ref.date", "variable" = "series.name", "value") %>%
dplyr::mutate(date = tsibble::yearmonth(.data$date)) %>%
tsibble::as_tsibble(key = "variable", index = "date")
anfavea

Uma rápida visualização dos dados sempre é importante:

anfavea %>%
fabletools::autoplot(value) +
ggplot2::facet_wrap(
~variable, 
scales = "free_y"
) +
ggplot2::labs(
title = "Produção de veículos desagregada - Brasil",
x = NULL,
y = "Unidades",
caption = "Dados: ANFAVEA | Elaboração: analisemacro.com.br"
) +
ggplot2::theme(legend.position = "none")

Para gerar previsões hierárquicas usaremos a família de pacotes do tidyverts (você não leu errado), que possibilita um fluxo de trabalho em apenas 5 passos:

1) Transforme os dados para um objeto tsibble contendo as séries desagregadas do nível inferior (em nosso exemplo todas exceto o "Total");

2) Utilize fabletools::aggregate_key() para definir a estrutura de agregação;

3) Especifique um modelo a ser estimado com fabletools::model() para cada série e suas desagregações;

4) Utilize fabletools::reconcile() para indicar uma abordagem (bottom-up, top-down, etc.) para gerar previsões desagregadas coerentes de acordo com o modelo;

5) Por fim, use a função fabletools::forecast() para gerar previsões para toda a estrutura de agregação.

Especificando a hierarquia da série:


prod_veiculos <- anfavea %>%
dplyr::filter(!variable == "Total") %>%
fabletools::aggregate_key(variable, value = sum(value, na.rm = TRUE))
prod_veiculos

Estimar modelos restringindo a amostra e apontar abordagens de previsão hierárquica:


fit <- prod_veiculos %>%
dplyr::filter(lubridate::year(.data$date) <= 2017) %>%
fabletools::model(baseline = fable::ETS(value)) %>%
fabletools::reconcile(
bottom_up = fabletools::bottom_up(baseline),
top_down = fabletools::top_down(baseline),
ols = fabletools::min_trace(baseline, method = "ols")
)
fit

Gerar previsões fora da amostra:


fcst <- fabletools::forecast(fit, h = "2 years")
fcst

Visualizar previsões geradas (produção agregada e desagregada):


fcst %>%
fabletools::autoplot(
dplyr::filter(
prod_veiculos,
dplyr::between(
lubridate::year(.data$date),
2015,
2019
)
),
level = NULL,
size = 1.1
) +
ggplot2::facet_wrap(
~variable,
scales = "free_y"
) +
ggplot2::labs(
title = "Previsão hierárquica da produção de veículos",
y = "Unidades",
x = NULL
)

Calcular métricas de acurácia:


fcst %>%
dplyr::filter(fabletools::is_aggregated(variable)) %>%
fabletools::accuracy(prod_veiculos) %>%
dplyr::arrange(RMSE)

O objeto fcst de classe fable contém as previsões baseline bem como as previsões coerentes de cada abordagem, para as três categorias de veículos desagregadas e para a produção total. Vale enfatizar que as previsões agregadas baseline serão diferentes das previsões agregadas pela abordagem bottom_up, por exemplo.

Dado a escala das séries em diferentes níveis de agregação serem bastante diferentes, devido à agregação, deve-se tomar cuidado ao avaliar as métricas de acurácia. Acima exibimos a acurácia para a série agregada (produção total) conforme cada abordagem/modelo.

Neste caso, agregar as previsões baseline usando a abordagem top-down resultou em previsões mais precisas em comparação com a abordagem bottom-up.

Por fim, vale destacar que o objetivo desse exercício não contempla nenhum aprofundamento ou preocupação com a especificação econométrica, ajuste ou acurácia do(s) modelo(s), focando apenas na implementação prática de previsões hierárquicas.

 

Referências

Hyndman, R.J., & Athanasopoulos, G. (2021) Forecasting: principles and practice, 3rd edition, OTexts: Melbourne, Australia. OTexts.com/fpp3. Accessed on <2021-12-23>.

Athanasopoulos, G., Ahmed, R. A., & Hyndman, R. J. (2009). Hierarchical forecasts for Australian domestic tourism. International Journal of Forecasting, 25, 146–166.

Gross, C. W., & Sohl, J. E. (1990). Disaggregation methods to expedite product line forecasting. Journal of Forecasting, 9, 233–254.

Hyndman, R. J., Ahmed, R. A., Athanasopoulos, G., & Shang, H. L. (2011). Optimal combination forecasts for hierarchical time series. Computational Statistics and Data Analysis, 55(9), 2579–2589.

Panagiotelis, A., Athanasopoulos, G., Gamakumara, P., & Hyndman, R. J. (2021). Forecast reconciliation: A geometric view with new insights on bias correction. International Journal of Forecasting, 37(1), 343–359.

Wickramasuriya, S., Athanasopoulos, G., & Hyndman, R. (2019). Optimal forecast reconciliation for hierarchical and grouped time series through trace minimization. Journal of the American Statistical Association, 114(526), 804–819.


1 Outros exemplos comuns de séries temporais que podem ser desagregadas são: IPCA, IGP-M, Contas Nacionais, produção industrial, consumo de energia elétrica, etc.

 

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.

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":""}