Tag

deflacionar séries Archives - Análise Macro

Como deflacionar uma série no R

By | Dados Macroeconômicos, Data Science, Economia, Hackeando o R

Algumas pessoas ainda devem se lembrar de quando era possível "fazer o rancho", as compras do mês, com apenas cem reais no bolso, mas já faz bastante tempo que uma simples ida ao supermercado é deveras custosa. O carro popular que podia ser adquirido por menos de R$ 30 mil nos anos 1990 é facilmente vendido por não menos de R$ 50 mil hoje. Ou seja, com uma nota de R$ 100 não se compra a mesma quantidade de bens hoje do que era possível há 20 anos e isso constitui um problema econômico básico, motivo pelo qual devemos deflacionar valores monetários para poder compará-los no tempo.

Sendo assim, se queremos ter uma visão realística quando analisando uma série de preços, devemos transformar os valores nominais para valores deflacionados, ou reais, contabilizando o efeito inflacionário do período. Apesar de ser um procedimento padrão, costumam haver alguns equívocos, de modo que iremos esclarecer alguns pontos e explorar uma abordagem moderna da técnica usando a linguagem R.

Para transformar uma série de preços para valores reais, são necessárias duas coisas: os dados nominais e um índice de preços adequado. A série de dados nominais pode ser qualquer uma que mede algo em valores correntes (R$), como por exemplo a série do salário mínimo, disponibilizada pelo IPEADATA. Já o índice de preços adequado pode vir de diversas fontes, os mais conhecidos no Brasil são o Índice Nacional de Preços ao Consumidor Amplo (IPCA), o Índice Nacional de Preços ao Consumidor (INPC) e o Índice Geral de Preços - Mercado (IGP-M), este divulgado pela FGV e aqueles pelo IBGE. O que esses índices fazem é medir o preço de uma cesta de produtos em um dado período de tempo, geralmente um mês cheio, em relação a um outro período de tempo base.

Com esses dois dados, basta aplicar a fórmula de deflacionamento a seguir:

Onde:

é o valor real, ou deflacionado, no período i na data-base j

 

é o índice de preços fixado na data-base j

 

é o índice de preços no período i

 

é o valor ou preço nominal no período i

 

Com esta fórmula é possível obter o valor deflacionado a partir da multiplicação do valor nominal em um dado período pela razão entre o índice de preços na data-base de referência em relação ao índice no período de análise/interesse. Agora vamos exemplificar com dados para facilitar o entendimento.

Como exemplo, usaremos os dados do salário mínimo do Brasil a partir de 2000 e o INPC para deflacionar a série. Podemos obter esses dados no R com o código a seguir:

# Instalar/carregar pacotes
if(!require("pacman")) install.packages("pacman")
pacman::p_load(
"deflateBR",
"dplyr",
"lubridate",
"httr",
"sidrar",
"purrr",
"ggplot2",
"deflateBR",
"tidyr",
"magrittr"
)

## Coletar dados
# Salário mínimo nominal (código IPEADATA = MTE12_SALMIN12) usando web-scrapping
dados_nominal <- httr::GET(
"http://ipeadata.gov.br/api/odata4/ValoresSerie(SERCODIGO='MTE12_SALMIN12')"
)

# Dados do INPC usando API do Sidra/IBGE
dados_indice <- sidrar::get_sidra(api = "/t/1736/n1/all/v/2289/p/all/d/v2289%2013")

## Tratar dados e filtrar desde o ano 2000
# Salário mínimo nominal
nominal <- httr::content(dados_nominal)[[2]] %>% 
dplyr::bind_rows() %>% 
dplyr::select("date" = `VALDATA`, "nominal" = `VALVALOR`) %>% 
dplyr::mutate(date = lubridate::as_date(date)) %>% 
dplyr::filter(date >= as.Date("2000-01-01"))

# INPC
indice <- dados_indice %>% 
dplyr::select(
"date" = `Mês (Código)`,
"indice" = `Valor`
) %>%
dplyr::mutate(date = lubridate::ym(date))

## Juntar dados
salario_minimo <- dplyr::left_join(nominal, indice, by = "date") %>% 
tidyr::drop_na()

Os dados obtidos podem ser visualizados na tabela abaixo:

Agora vamos supor que queremos saber o salário mínimo real de novembro de 2020 na data-base de abril de 2021. Primeiro calculamos o chamado fator de deflacionamento, que é a fração entre parênteses na fórmula acima, fixando a data-base em abril/2021. O resultado e o cálculo podem ser vistos a seguir:

# Calcular fator de deflacionamento
salario_minimo %<>% 
dplyr::mutate(
fator = (indice2022/indice)
)

Em seguida, para transformar o valor nominal (R$ 1.045,00) em valor real, basta multiplicá-lo por 1,0384, isto é, R$ 1.045,00 de novembro de 2020 equivale a R$ 1.085,12 em abril de 2021.

Agora que sabemos o procedimento passo a passo do cálculo de deflacionamento, vamos aplicar a fórmula na série do salário mínimo e plotar um gráfico comparativo.

# Calcular salário mínimo real
salario_minimo %<>% 
dplyr::mutate(
real = (indice2022/indice) * nominal
)

# Visualização de dados
ggplot2::ggplot(salario_minimo, ggplot2::aes(x = date))+
ggplot2::geom_line(
ggplot2::aes(y = nominal, colour = "Salário Mínimo - Nominal"), size = 1.5
) +
ggplot2::geom_line(
ggplot2::aes(y = real, colour = "Salário Mínimo - Real"), size = 1.5
) +
ggplot2::scale_colour_manual(NULL, values = c("#282f6b", "#b22200")) + 
ggplot2::scale_y_continuous(n.breaks = 8) +
ggplot2::labs(
x = NULL,
y = "R$",
title = "Salário Mínimo no Brasil",
subtitle = "Valores em Reais deflacionados pelo INPC a preços de abril/2021.",
caption = "Fonte: analisemacro.com.br com dados de IBGE e IPEA."
) +
ggplot2::theme(
legend.position = "bottom",
plot.title = ggplot2::element_text(face = "bold"),
plot.subtitle = ggplot2::element_text(face = "italic"),
legend.text = ggplot2::element_text(face = "bold")
)

 

Perceba que, apesar de ser simples e fácil, é um pouco trabalhoso obter os dados do índice, tratar, fazer o cálculo, etc., para enfim obter nossa série deflacionada, mesmo que em nosso exemplo tenhamos "quebrado" o procedimento em etapas adicionais para fins de didática. Felizmente, existe um pacote no R chamado deflateBR que facilita essas tarefas em uma única função, criado pelo Fernando Meireles.

Com a função deflate, tudo que precisamos é apontar a série que queremos deflacionar, o vetor de datas correspondentes, uma data-base e um índice de preços que pode ser: IPCA, IGP-M, IGP-DI, IPC ou INPC. Vamos ao exemplo anterior usando essa função. criaremos uma outra coluna em nosso objeto nomeando-a "deflacionado" para diferenciar dos valores anteriores já calculados:

# Deflacionar usando o pacote deflateBR
salario_minimo %<>% 
dplyr::mutate(
deflacionado = deflateBR::deflate(
nominal_values = nominal,
nominal_dates = date %m+% months(1), # evitar que a função pegue valor com 1 lag
real_date = format(tail(date, 1), "%m/%Y"), 
index = "inpc"
)
)

# Verificar se valores são iguais
all.equal(salario_minimo$real, salario_minimo$deflacionado)

# [1] TRUE

Note que o cálculo foi exatamente o mesmo, mas bastou que indicássemos para a função o que e por qual índice necessitamos deflacionar, muito mais simples e prático.

Por fim, vamos confrontar nossos cálculos com os cálculos do IPEA, haja visto que o mesmo disponibiliza em sua plataforma a série do salário mínimo real. Assim certificamos de que fizemos tudo corretamente:

# Salário mínimo real IPEA (código IPEADATA = GAC12_SALMINRE12) usando web-scrapping
dados_real <- httr::GET(
"http://ipeadata.gov.br/api/odata4/ValoresSerie(SERCODIGO='GAC12_SALMINRE12')"
)

# Salário mínimo real IPEA
real <- httr::content(dados_real)[[2]] %>% 
dplyr::bind_rows() %>% 
dplyr::select("date" = `VALDATA`, "ipea" = `VALVALOR`) %>% 
dplyr::mutate(date = lubridate::as_date(date)) %>% 
dplyr::filter(date >= as.Date("2000-01-01"))

# Juntar dados e arredondar casas decimais
salario_minimo <- left_join(salario_minimo, real, by = "date") %>% 
dplyr::mutate(dplyr::across(real:ipea, ~round(.x, 2)))

# Verificar se valores são iguais
all.equal(salario_minimo$real, salario_minimo$ipea)

# [1] TRUE

Assim, demonstramos duas formas de deflacionar valores usando o R, ambas equivalentes entre si.

 

Deflacionando variáveis macroeconômicas com o R

By | Dados Macroeconômicos

Nosso objetivo no Curso de Teoria Macroeconômica com Laboratórios de R é o de fornecer uma introdução aplicada à macroeconomia. Serve tanto para alunos e professores de economia, em busca de ferramentas mais aplicadas para lidar com variáveis macroeconômicas, quanto para profissionais de outras áreas em busca de conhecimentos em macroeconomia.

Para ilustrar o que vemos no Curso, vou mostrar aqui nesse post como é possível deflacionar uma série econômica, dúvida muito comum entre nossos alunos. Sabemos todos que R$ 100 em dezembro de 1997 não é a mesma coisa que R$ 100 em dezembro de 2016, não é mesmo? Logo, para comparar valores no tempo é preciso que levemos em consideração a taxa de crescimento do nível geral de preços, ou simplesmente a inflação. Para comparar valores nominais em dois períodos distintos, é preciso que tenhamos a mesma base de preços. Para ilustrar, vamos dar um exemplo utilizando a despesa com benefícios previdenciários do governo central. Para deflacionar, vamos utilizar o Índice de Preços ao Consumidor Amplo (IPCA).


library(readxl)
library(tidyverse)
library(ggplot2)
library(magrittr)
library(lubridate)
library(sidrar)

data = read_excel("primario.xlsx")

data %>% pivot_longer(-date, names_to='Variável', values_to='valor') %>%
ggplot(aes(x=date, y=valor, color=Variável)) + geom_line() +
labs(title='Receitas e despesas com benefícios previdenciários', x='Data',
y='Valor', color='') +
theme_light()

O gráfico acima ilustra as nossas séries em valores nominais. Na sequência, fazemos o ajuste para valores reais com base no IPCA.


ipca = get_sidra(api='/t/1737/n1/all/v/2266/p/all/d/v2266%2013')

ipca %<>% mutate(date = parse_date_time(`Mês (Código)`, 'ym'))

ajuste <- left_join(ipca, data, by='date') %>%
select(date, Valor, receita, despesa) %>%
na.omit() %>%
mutate('Receita ajustada' = receita/Valor*Valor[274],
'Despesa ajustada' = despesa/Valor*Valor[274])

ajuste %>% select(date, receita, 'Receita ajustada') %>%
pivot_longer(-date, names_to = 'Variáveis', values_to = 'Valor') %>%
ggplot(aes(x=date, y=Valor, color=Variáveis)) + geom_line() +
labs(title='Receitas com benefícios previdenciários nominais e reais', x='Data',
color='') +
theme_light()

No gráfico acima, vemos os valores nominais e reais das receitas com benefícios previdenciários. A título de comparação, é necessário sempre usar valores reais.

________________

(*) Isso e muito mais você irá aprender no nosso Curso de Teoria Macroeconômica com Laboratórios de R.

Obtendo valores deflacionados com o R

By | Macroeconometria

Uma dúvida muito comum entre os alunos dos Cursos Aplicados em R da Análise Macro é como obter valores deflacionados ou reais. De forma a ilustrar o processo, vamos pegar os saldos de transações de crédito total, pessoa física e pessoa jurídica a partir do pacote BETS do Sistema de Séries Temporais do Banco Central. Esse foi, a propósito, o exercício 39 do Clube do Código.


total = window(BETS.get(20539), start=c(2007,03))
pj = BETS.get(20540)
pf = BETS.get(20541)

 

Abaixo os gráficos das séries...


times = seq(as.Date('2007-03-01'), as.Date('2018-04-01'), 
by='1 month')
df = data.frame(time=times, total=total,
pj=pj, pf=pf)
ggplot(df, aes(x=time))+
geom_line(aes(y=total/1000, colour='Total'), size=.8)+
geom_line(aes(y=pj/1000, colour='Pessoa Jurídica'), size=.8)+
geom_line(aes(y=pf/1000, colour='Pessoa Física'), size=.8)+
scale_colour_manual('', values=c('Total'='blue',
'Pessoa Jurídica'='darkgreen',
'Pessoa Física'='red'))+
theme(legend.position = 'top')+
xlab('')+ylab('R$ milhões')+
labs(title='Saldo de Operações de Crédito (R$ milhões)',
subtitle='Valores Correntes',
caption='Fonte: elaboração própria com dados do BCB.')+
scale_y_discrete(limits=c(500,1000,1500,2000,2500,3000))+
scale_x_date(breaks = date_breaks("1 years"),
labels = date_format("%Y"))+
annotate("rect", fill = "lightblue", alpha = 0.3, 
xmin = as.Date('2016-01-01'), 
xmax = as.Date('2018-04-01'),
ymin = -Inf, ymax = Inf)

As séries estão, naturalmente, em valores correntes ou nominais. De forma a colocá-las em valores reais, precisamos de um deflator. Com o código abaixo, por suposto, importamos o número-índice do IPCA da base de dados SIDRA do IBGE, com o pacote SidraR.


ipca = get_sidra(api='/t/1737/n1/all/v/2266/p/all/d/v2266%2013')
ipca = ts(ipca$Valor, start=c(1979,12), freq=12)
ipca = window(ipca, start=start(total))

De posse do número-índice do IPCA, podemos aplicar a seguinte fórmula sobre as nossas séries:

(1)   \begin{align*} V_{r} = V_{t} \times \begin{pmatrix} \frac{I_{k}}{I_{t}} \end{pmatrix} \end{align*}

onde o valor real V_{r} será obtido multiplicando o valor nominal em t pela razão entre o índice de preço no período k e no período t. Em assim sendo, podemos trazer os valores das nossas séries aos preços de abril de 2018, com o código a seguir.


credito = ts.intersect(total, pf, pj)
credito.real = credito*(ipca[length(ipca)]/ipca)
colnames(credito.real) = colnames(credito)

Abaixo comparamos os valores reais e nominais do saldo de transações de crédito total.

 

Variações Nominais vs. Variações Reais

Por suposto, podemos construir variações sobre valores reais e nominais. Caso, façamos, por exemplo, uma variação acumulada em 12 meses dos valores nominais, tudo o que teremos será uma variação nominal. Veja, por exemplo, com o código abaixo.


anual = (credito/lag(credito,-12)-1)*100
colnames(anual) = colnames(credito)

E abaixo um gráfico.

Podemos, agora, transformar essas variações nominais em reais de duas formas. Primeiro, podemos simplesmente fazer a mesma operação acima, mas utilizando as séries reais que construímos acima.


anual.real = (credito.real/lag(credito.real,-12)-1)*100
colnames(anual.real) = colnames(credito)

Ou podemos aplicar a fórmula

(2)   \begin{align*} \Delta_{real} = \begin{bmatrix} \begin{pmatrix} \frac{1 + (V_{nom}/100)}{1+ (\pi/100)} \end{pmatrix}-1 \end{bmatrix} \times 100 \end{align*}

onde, \pi é a inflação do período. O código abaixo operacionaliza.


ipca2 = window(BETS.get(13522), start=c(2008,03))
anual = (credito/lag(credito,-12)-1)*100
anual.real2 = (((1+(anual/100))/(1+(ipca2/100)))-1)*100
colnames(anual.real2) = colnames(credito)

Uma vez calculadas as variações das séries, plotamos um gráfico, como abaixo.

Update: por óbvio, para rodar o código é preciso carregar os pacotes BETS, ggplot2, sidrar e scales.

Como deflacionar uma série?

By | Inflação

Uma dúvida muito comum entre os alunos - que tratamos em nosso Curso de Análise de Conjuntura usando o R - é como deflacionar uma série. Sabemos todos que R$ 100 em dezembro de 1997 não é a mesma coisa que R$ 100 em dezembro de 2016, não é mesmo? Logo, para comparar valores no tempo é preciso que levemos em consideração a taxa de crescimento do nível geral de preços, ou simplesmente a inflação. Para comparar valores nominais em dois períodos distintos, é preciso que tenhamos a mesma base de preços. Para ilustrar, vamos dar um exemplo utilizando a despesa com benefícios previdenciários do governo central. Para deflacionar vamos utilizar o Índice de Preços ao Consumidor Amplo (IPCA).

Para esse exercício, utilizei uma amostra que vai de janeiro de 1997 a dezembro de 2016. A série nominal de despesa com benefícios previdenciários é posta abaixo.

Com a série nominal em mãos, precisamos do número índice do IPCA para começar a brincadeira. Uma vez tendo ele (consulte o código do exercício para saber como importar para o R), podemos aplicar a fórmula básica abaixo:

(1)   \begin{equation*} V_{r} = V_{t}*\frac{I_{k}}{I_{t}} \end{equation*}

onde o valor real V_{r} será obtido multiplicando o valor nominal em t pela razão entre o índice de preço no período k e no período t. Assim, se queremos deflacionar as despesas com benefícios previdenciários, podemos definir o período k como dezembro de 2016. Toda a inflação entre o período k e o período t será agora considerada e, portanto, podemos comparar os valores no tempo. No R, o código abaixo faz isso.

## Deflacionar série
data$prevreal = data[,3]*(tail(data[,2],1)/data[,2])

E abaixo um gráfico com a série nominal e a série real...

No nosso Curso de Análise de Conjuntura usando o R tratamos essa e outras questões de coleta e tratamento de dados macroeconômicos. Clique no link e conheça o curso!

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

Assinar Gratuitamente