Explorando o pacote dplyr: lag/lead

Introdução

As funções lag() e lead() são recursos poderosos do pacote dplyr no R que nos permitem analisar diferenças e tendências temporais em conjuntos de dados. Com essas funções, podemos facilmente comparar valores anteriores e posteriores em uma sequência, o que é útil para identificar padrões, mudanças e comportamentos ao longo do tempo. Neste post, exploraremos a funcionalidade dessas funções usando um exemplo prático.

Antes de prosseguirmos, certifique-se de ter instalado o pacote dplyr.

install.packages("dplyr")

Sintaxe

A sintaxe básica da função lag() é a seguinte:

dplyr::lag(x, n = 1L, default = NULL, order_by = NULL, ...)

• x: um vetor.

• n: o número de posições para trás que queremos retroceder. Por padrão, é 1, o que significa que a função retornará o valor anterior à posição atual.

• default: valor padrão a ser retornado caso não haja valor anterior disponível. Por padrão, é definido como NULL, o que significa que, se não houver valor anterior, a função retornará NA.

• order_by: uma coluna usada para ordenar os dados. Se não for especificado, a função lag() assumirá que os dados estão na ordem em que aparecem no conjunto de dados.

Exemplo simples

Considere o seguinte conjunto de dados:

tab <- tibble::tibble(
  medida = c(1, 2, 1, 3, 4, 1, 2, 0)
)

Neste exemplo, temos uma coluna chamada “medida” que contém valores numéricos. Vamos começar utilizando a função lag() para criar uma nova coluna chamada “lag_medida”, que armazenará o valor anterior de “medida” em cada linha:

tab |>
  dplyr::mutate(
    lag_medida = dplyr::lag(medida)
  )

## # A tibble: 8 × 2
##   medida lag_medida
##    <dbl>      <dbl>
## 1      1         NA
## 2      2          1
## 3      1          2
## 4      3          1
## 5      4          3
## 6      1          4
## 7      2          1
## 8      0          2

Observe que a primeira linha da coluna “lag_medida” é NA porque não há um valor anterior para a primeira observação.

Agora, vamos criar uma nova coluna chamada “flag_aumentou”, que indicará se o valor atual de “medida” é maior que o valor anterior:

tab |> 
  dplyr::mutate(
    lag_medida = dplyr::lag(medida),
    flag_aumentou = medida > lag_medida
  )

## # A tibble: 8 × 3
##   medida lag_medida flag_aumentou
##    <dbl>      <dbl> <lgl>        
## 1      1         NA NA           
## 2      2          1 TRUE         
## 3      1          2 FALSE        
## 4      3          1 TRUE         
## 5      4          3 TRUE         
## 6      1          4 FALSE        
## 7      2          1 TRUE         
## 8      0          2 FALSE

A coluna flag_aumentou nos informa se a medida atual é maior que a medida anterior (TRUE) ou não (FALSE). Esse tipo de informação pode ser útil para identificar momentos de crescimento ou decrescimento em séries temporais.

Exemplo com dados agrupados

Vamos agora explorar como utilizá-la em dados agrupados por indivíduo. Essa situação é comum quando temos uma série temporal para cada indivíduo em nosso conjunto de dados e desejamos analisar as variações dentro de cada grupo ao longo do tempo. Considere a tabela:

tab <- tibble::tibble(
  individuo = rep(1:2, each = 4), # Dois indivíduos com 4 medidas cada
  medida = c(1, 2 , 1, 3, 4, 1, 2, 0)
)

tab

## # A tibble: 8 × 2
##   individuo medida
##       <int>  <dbl>
## 1         1      1
## 2         1      2
## 3         1      1
## 4         1      3
## 5         2      4
## 6         2      1
## 7         2      2
## 8         2      0

A seguir, utilizamos a função lag() para criar uma nova coluna com a medida anterior, agrupado por indivíduo.

tab |> 
  dplyr::group_by(individuo) |> 
  dplyr::mutate(
    lag_medida = dplyr::lag(medida)
  )

## # A tibble: 8 × 3
## # Groups:   individuo [2]
##   individuo medida lag_medida
##       <int>  <dbl>      <dbl>
## 1         1      1         NA
## 2         1      2          1
## 3         1      1          2
## 4         1      3          1
## 5         2      4         NA
## 6         2      1          4
## 7         2      2          1
## 8         2      0          2

Observe que a coluna lag_medida agora contém a medida anterior para cada indivíduo, respeitando os grupos criados pela coluna individuo.

Vamos dar um passo adiante e criar uma nova coluna chamada flag_aumentou, assim como fizemos no exemplo anterior:

tab |> 
  dplyr::group_by(individuo) |> 
  dplyr::mutate(
    lag_medida = dplyr::lag(medida),
    flag_aumentou = medida > lag_medida
  )

## # A tibble: 8 × 4
## # Groups:   individuo [2]
##   individuo medida lag_medida flag_aumentou
##       <int>  <dbl>      <dbl> <lgl>        
## 1         1      1         NA NA           
## 2         1      2          1 TRUE         
## 3         1      1          2 FALSE        
## 4         1      3          1 TRUE         
## 5         2      4         NA NA           
## 6         2      1          4 FALSE        
## 7         2      2          1 TRUE         
## 8         2      0          2 FALSE

Agora temos a coluna flag_aumentou indicando se a medida atual é maior que a medida anterior, dentro de cada grupo de indivíduo.

A função lead().

Enquanto lag() retorna valores anteriores de uma coluna, a função lead() retorna valores seguintes de uma coluna em relação à posição atual.

Como exercício, usando a função lead(), tente reproduzir os dois exemplos acima comparando o valor atual da coluna medida agora com o seu valor posterior (e não mais com o anterior).

---

É isso! Dúvidas, sugestões e críticas, mande aqui nos comentários.