Sessão 3 - Funções da família apply

• Veja um exemplo da utilização de apply():

# Construindo uma matriz 5x6
X <- matrix(1:30, nrow=5, ncol=6)
X

     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    1    6   11   16   21   26
[2,]    2    7   12   17   22   27
[3,]    3    8   13   18   23   28
[4,]    4    9   14   19   24   29
[5,]    5   10   15   20   25   30

# somar o TOTAL de cada coluna com apply()
apply(X, 2, sum)

[1]  15  40  65  90 115 140

• Para entendermos o que está sendo feito no código ao lado, vejamos a figura:

• Fonte: Datacamp

apply(X, 2, sum) siginifica: aplique a função sum sobre as colunas (ou ao longo da margem/dimensão 2) da matriz X.

• Caso você deseje especificar/passar algum parâmetro da função (FUN) a ser utilizada, pode proceder como no exemplo a seguir:

# Construindo uma matriz 5x6
X <- matrix(1:30, nrow=5, ncol=6)

# inserindo alguns NA's
X[1,2] <- NA
X[4,5] <- NA

X

     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    1   NA   11   16   21   26
[2,]    2    7   12   17   22   27
[3,]    3    8   13   18   23   28
[4,]    4    9   14   19   NA   29
[5,]    5   10   15   20   25   30

# somar o valor de cada coluna com apply(), agora incluindo o parâmetro na.rm= TRUE
apply(X, 2, sum, na.rm = TRUE)

[1]  15  34  65  90  91 140

• Note que o parâmetro na.rm, embora pertencente a função sum(), não é passado dentro desta, mas sim como um argumento de apply(). Será a função apply() que se encarregará de direcionar este argumento para a função sum();

• Veja a diferença caso não tivessemos especificado na.rm = TRUE

apply(X, 2, sum)

[1]  15  NA  65  90  NA 140

• Considere a situação em que desejamos pegar o valor MÍNIMO de cada linha e aplicarmos uma taxa de correção de 25%, salvando os resultados num vetor:

# criando matriz
set.seed(1984) # semente para reproducibilidade dos valores
M <- matrix(sample(1:1000, 30), 5)
M

     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]  659  859  874   23  599  154
[2,]  437   33   12  295    4  826
[3,]  373  445  698  654  600  566
[4,]  330  824  711  906  839  493
[5,]  735  213  200  202  780  538

# 1º caso - utlizando função anônima
apply(M, 1, function(x) min(x)*1.025)

[1]  23.575   4.100 382.325 338.250 205.000

# 2º caso - criando uma função fora de apply()
myfun <- function(x) min(x)*1.025

apply(M, 1, myfun)

[1]  23.575   4.100 382.325 338.250 205.000

• Os resultados são exatamente os mesmos!

• Note que a criação da função anônima se dá da mesma forma em que criaríamos uma função normal, conforme visto no primeiro capítulo.

• As únicas diferenças são: a função é criada dentro do argumento FUN da função da família apply e não atribuímos qualquer nome para a função que está sendo criada.

• lapply() é uma das funções mais básicas da família apply;
• Ela receberá como input uma lista, aplicará uma função aos elementos desta lista, retornando também uma lista;
• Uma observação a ser feita é que, caso o objeto inputado não seja uma lista, internamente, lapply() forçará esse objeto a ser uma lista utilizando as.list();
• Portanto, fica claro o motivo do l em lapply();

• Veja a imagem exemplificando o funcionamento de lapply():

• 

Fonte: Advanced R

• A estrutura de argumentos de lapply() é bem parecida com a função apply();
• A diferença é que desta vez não temos o argumento MARGIN.

args(lapply)

function (X, FUN, ...) 
NULL

• Veja um exemplo do uso de lapply():

# criando 3 matrizes:
A <- matrix(1:9, 3)
B <- matrix(4:15, 4)
C <- matrix(rep(8:10, 2), 3)

# Criando lista de matrizes
MyList <- list(A,B,C)

# Extratraindo a primeira linha de todas as matrizes da lista `MyList`
lapply(MyList,"[", 1,) 

[[1]]
[1] 1 4 7

[[2]]
[1]  4  8 12

[[3]]
[1] 8 8

# note como é passado o argumento da primira linha

• A figura a seguir auxilia na compreensão do exemplo:

• 

Fonte: Datacamp.

• Para extrair somente o segundo elemento da primeira linha de cada matriz, por exemplo, passaríamos o índice da coluna além da linha:

lapply(MyList,"[", 1,2) 

[[1]]
[1] 4

[[2]]
[1] 8

[[3]]
[1] 8

• Vejamos como ficaria lapply, utilizando uma função anônima. Vamos tentar calcular a média de todas as primeiras colunas das matrizes A, B, C do exemplo anterior:

lapply(MyList, function(x) mean(x[,1],na.rm=TRUE))

[[1]]
[1] 2

[[2]]
[1] 5.5

[[3]]
[1] 9

# OU
lapply(MyList, function(x, ...) mean(x[,1]), na.rm=TRUE)

[[1]]
[1] 2

[[2]]
[1] 5.5

[[3]]
[1] 9

# perceba o uso de ... e o posicionamento de na.rm nas duas formas equivalentes acima

# OU AINDA:
# de uma maneira menos eficiente (porque teríamos que criar um vetor, ocupando mais memória) e mais complicada porque teríamos que usar 2 vezes lapply()

out <- lapply(MyList, "[", ,1) 
# esse só funciona com lapply. Com sapply não dá certo por causa da 3ª vírgula, me parece. Como sapply() é um wrapper para lapply, na hora de ela tentar mandar para lapply, ela entende a 3ª vírgula como se fosse um agumento e não um parâmetro.

lapply(out, mean)

[[1]]
[1] 2

[[2]]
[1] 5.5

[[3]]
[1] 9

# mean aplicado sobre uma lista não funciona
# ... então não adiantaria usar o código abaixo:
# mean(out, na.rm = TRUE)

• vapply() é muito similar a sapply(), no sentido de que também busca produzir um vetor como saída;
• A diferença é: sapply() tenta 'advinhar' qual seria o output, ao passo que vapply() utiliza um argumento adicional que serve para especificar o tipo e tamanho de saída/ output que esperamos após aplicar a função nos dados;
• vapply somente retornará um vetor (ou array), daí o v de vapply();

• Hadley Wickham sugere utilizar vapply() (ao invés de sapply()):
  • ela “reclamará” sempre que houver algum erro no tipo de input;
  • sapply(), por sua vez pode falhar de modo “silencioso” sem indicar algo de errado que esteja ocorrendo.
• Para programação de forma interativa (quando sabemos o tipo de dado que está sendo inputado) sapply() pode ser utilizada sem problemas;
• No entanto, quando vamos escrever programas longos que serão executados de forma automática por outros usuários, onde a função da família apply seria executada dentro de outras funções, a opção mais segura seria vapply().

Comparando vapply() e sapply()…

• No exemplo a seguir, vamos criar obter os tipos de colunas de um data.frame simulado. Primeiro o teste com sapply():

# criando um data.frame
df <- data.frame(x = 1:10, y = letters[1:10])

# aplicando sapply
sapply(df, class)

        x         y 
"integer"  "factor" 

• E agora, o teste com vapply(). Note que estamos passando o tipo e tamanho do vetor que esperamos ter como resultado:

# aplicando vapply
vapply(df, class, character(1))

        x         y 
"integer"  "factor" 

• Veja o que ocorre caso tivéssemos especificado erroneamente o tipo ou o tamanho do vetor de saída:

# errando no tipo:
vapply(df, class, numeric(1))

# errando no tamanho:
vapply(df, class, character()) # R vai entender como tamanho zero.

• Para visualizarmos efetivamente a importância de usar vapply() no sentido de controlarmos o input dos dados e detectarmos possíveis erros, vejamos o seguinte exemplo: verificar as classes das colunas d eum data.frame:

# primeiro com sapply()
# criando um data.frame com uma coluna de datas
df2 <- data.frame(x = 1:10, y = Sys.time() + 1:10)

sapply(df2, class)

$x
[1] "integer"

$y
[1] "POSIXct" "POSIXt" 

• E depois com vapply():

vapply(df2, class, character(1))

Error in vapply(df2, class, character(1)): values must be length 1,
 but FUN(X[[2]]) result is length 2

• Ao usar sapply(), esperávamos classes com um único nome (um único elemento por coluna);

  • No entanto, a coluna de datas possui um nome “duplo” e sapply acaba separando a segunda parte do nome, retornando um vetor com duas entradas quando esperávamos apenas uma;
  • Isso pode nos levar a um engano de achar que havia uma terceira coluna no data.frame, o que não é verdade.

• Por outro lado, vapply() retorna um erro;

  • Isso é bom, pois mostra que estávamos enganados ao esperar apenas vetores de caracteres com tamanho 1 como a classe de cada coluna;
  • Nos força a conhecer exatamente o que deve ser retornado em cada caso.

• Pense em como faríamos para somar todos os primeiros elementos de objetos de duas listas diferentes, todos os elementos na segunda posição, todos os terceiros e assim por diante? A saída seria utilizar mapply():

# criando duas listas com sequências de vetores:
l1 <- list(a = c(1:5), b = c(6:10))

l2 <- list(c = c(11:20), d = c(21:30))

mapply(sum, l1$a, l1$b, l2$c, l2$d)

 [1] 39 43 47 51 55 49 53 57 61 65

#Map(sum, l1$a, l1$b, l2$c, l2$d)
# Reduce('+', c(l1, l2))

• O que está acontecendo acima é que estamos passando múltiplos argumentos a serem somados posição por posição pela função sum();

• Se passarmos os vetores inteiros para a função sum() sem mapply() todos os elementos seriam somados de uma vez;

• Ao usarmos mapply(), podemos passar vários vetores para função sum() de modo que ela some as resectivas posições de forma paralela: l1$a[1] + l1$b[1] + l2$c[1] + l2$d[1] = 39 e assim por diante.

• mapply() nos permite, então, vetorizar argumentos para uma função que normalmente não funcionaria de forma vetorizada;

• Com lapply() isso não seria possível, porque os argumentos adicionais são passados para todas as chamadas. Com mapply() é como se conseguíssemos segmentar conjuntos de argumentos para cada chamada.

• Há uma função parecida com tapply() que permite apresentar os resultados no formato de uma tabela/ data.frame;
• Ela nos permite aplicar funções de sumarização dos dados quando temos grupos;
• Você pode aplicar a sumarização a mais de uma variável ao mesmo tempo:

# criação de um novo vetor:
set.seed(123)
dias <- sample(1:360, 20)
df$dias <- dias

aggregate(df[,c("saldo", "dias")], by = df['banco'], mean)

  banco    saldo     dias
1    BB 565.2500 245.5000
2   CEF 577.4167 164.5833

# como o data.frame eh em sua essência uma lista, seus elementos são as colunas. Então ao indexarmos smente pelas colunas, sem indicar as vírgulas, ele automaticamente traz um data.frame (ou seja, uma lista). Dessa forma, conseguimos manter os nomes das variáveis !!!
# str(df['banco'])

aggregate(df[,c("saldo", "dias")], by = df['banco'], range)

  banco saldo.1 saldo.2 dias.1 dias.2
1    BB     228     705     17    357
2   CEF      25     992     15    356

• Se não usarmos a forma natural de lista no argumento by, teremos que forçar o resultado como uma lista usando list();

• Teremos o mesmo resultado, mas a diferença é que não teremos o nome da coluna de indexação trazido automaticamente como no exemplo acima:

aggregate(df[,c("saldo", "dias")], by = list(df$banco), mean)

  Group.1    saldo     dias
1      BB 565.2500 245.5000
2     CEF 577.4167 164.5833

aggregate(df[,c("saldo", "dias")], by = list(df$banco), range)

  Group.1 saldo.1 saldo.2 dias.1 dias.2
1      BB     228     705     17    357
2     CEF      25     992     15    356