Ferramentas do usuário

Ferramentas do site


Barra lateral

lcf5876:historico-disciplina:2018:programa:05-operacoes-objetos-dados:05-04-agregacao
  LCF-5876 Computação no Ambiente R:
Aplicações em Ecologia
e Recursos Florestais
R logo
5. OPERAÇÃO COM OBJETOS DE DADOS

5.4. Agregação

Agregação é a operação de resumir (sumarizar) uma variável (variável agregante) segundo os valores de uma variável ou segundo a combinação dos valores de um conjunto de variáveis (variáveis agregadoras).

No R, as variáveis agregadoras são sempre fatores. Portanto, a agregação ocorre segundo os níveis (levels) um factor ou segundo as combinações dos níveis de vários factors. Várias operações de sumarização podem ser realizadas: soma, contagem, cálculo da média, etc..

5.4.1. Agregação de Vetores


A função tapply realiza a agregação de um vetor segundo os níveis de um fator. Sua estratura é:

> args( tapply )
function (X, INDEX, FUN = NULL, ..., simplify = TRUE) 
NULL

Os argumentos são:

  • X é o vetor que será a variável agregante,
  • INDEX é uma lista de factors (ou um único) que serão as variáveis agregadoras,
  • FUN é a função de sumarização,
  • . . .” são outros argumentos que a função FUN possa necessitar,
  • simplify define o valor retornado pela tapply deve ser simplificado.

Vejamos alguns exemplos com único fator como agregador:

  1 ######################################################
  2 ########### 5. OPERAÇÃO COM OBJETO DE DADOS
  3 ########### 5.4. Agregação
  4 ######################################################
  5 # 5.4.1. Agregação de Vetores
  6
  7 sexo <- factor(rep(c("F","M"),each=9))
  8 dieta <- factor(rep(rep(c("normal","light","diet"),each=3),2),
  9                 levels=c("normal","light","diet"))
 10 peso <- c(65,69,83,90,58,84,85,74,92,71,72,78,67,65,62,74,73,68)
 11
 12 tapply( peso, sexo )
 13 tapply( peso, sexo , mean)
 14 tapply( peso, dieta, max )
 15 tapply( peso, dieta, min )
 16

Mas a agregação pode ser realizada por uma combinação de fatores:

 17 tapply( peso, list(sexo, dieta), mean )
 18 tapply( peso, list(sexo, dieta), sd )
 19

5.4.2. Agregação de Matrizes


A agregação de matrizes é realizada com a função apply, que funciona de modo semelhante à função tapply, mas no lugar da lista de factors basta indicar a dimensão na qual a agregação será realizada. Seus argumentos são:

> args(apply)
function (X, MARGIN, FUN, ...)
NULL
>

onde:

  • X é a matriz a ser agregada;
  • MARGEIN é a dimensão (ou margem) para agregação (1 = linha, 2 = coluna);
  • FUN é a função de agregação; e
  • . . . são outros argumentos necessários ao funcionamento da função FUN.

Como exemplo, utilizamos os dados de caixetais para construir uma matriz de presença/ausência das espécies nos diferentes caixetais (local):

 20 # 5.4.2. Agregação de Matrizes
 21
 22 caxg  = read.csv("caixeta-grande.csv", sep=";")
 23 dim(caxg)
 24 head(caxg)
 25

A função table é utilizada para construir a matriz de presença/ausência:

 26 ## Matriz de Presença/Ausência de Espécies
 27 tab.sp <- table(caxg$especie, caxg$local)
 28 tab.sp[ tab.sp > 1 ] <- 1
 29 head(tab.sp)
 30 apply(tab.sp, 1, sum)  # Número de caixetais (local) em que cada espécie ocorre
 31 apply(tab.sp, 2, sum)  # Número de espécies por caixetal (local)
 32

Com esses dados também se pode verificar em qual caixetal (local) tem densidade (arvores por parcela) mais variável:

 33 ## Matriz do Número de Árvores por Parcela
 34 tab.par <- table(caxg$parcela, caxg$local)
 35 tab.par
 36 apply(tab.par, 2, mean)
 37 apply(tab.par, 2, sd)
 38 apply(tab.par, 2, function(x) round(sd(x)/mean(x)*100,0))
 39

Agregação de Arrays

A função apply também é utilizada para agregar as informações em arrays. Nesse caso, o argumento MARGIN pode ser uma das dimensões do array ou uma combinação dessas dimensões:

 40 ## Agregação de Array
 41
 42 Titanic
 43 dimnames(Titanic)
 44 T <- apply(Titanic, c(1,2), sum)    # Total de pessoas no barco
 45 T
 46 S <- apply(Titanic, c(1,2,4), sum)  # Número de No/Yes para "Survived"
 47 S
 48 round(S[,,2] / T * 100, 0)          # Porcentagem de "Survived = Yes"
 49

5.4.3. Agregação de "Data Frames"


As operações de agregação com vetores são úteis, mas como a melhor forma de armazenar os dados é o data frame seria mais conveniente se as operações de agregação fossem realizadas com eles e, se possível, produzissem data frames como resultado.

A função aggregate nos permite fazer isso. Os seus argumentos, na agregação de data frames, são semelhantes a função tapply:

            aggregate(x, by, FUN, ...)
  • x: é um data.frame contendo apenas as variáveis agregantes;
  • by: é uma list com os fatores que serão as variáveis agregadoras;
  • FUN: é a função de agregação;
  • . . .” são outros argumentos necessários à função FUN.

Vejamos um exemplo utilizando um arquivo com muitos dados: caixeta-grande.csv.

 50 # 5.4.3. Agregação de "Data Frames"
 51
 52 caxg$dap = caxg$cap / (pi*10)
 53 caxg$g = (pi/4) * (caxg$dap/100)^2
 54 caxg$h = caxg$h/10
 55

Façamos o cálculo da média dos diâmetros (dap) e das alturas (h) dos fustes por parcela e local:

 56 cax.par.medias = aggregate( caxg[, c("dap","h")],
 57                         list(parcela=caxg$parcela, local=caxg$local),
 58                         mean)
 59 cax.par.medias
 60

Um cuidado importante é quando fornecemos como variável agregante apenas uma coluna de um data frame:

 61 cax.par.mdap = aggregate( caxg$dap, list(parcela=caxg$parcela,
 62                         local=caxg$local),
 63                         mean)
 64 cax.par.mdap
 65

Note que a terceira coluna do data frame retornado tem o nome x. Isso acontece pois ao extraírmos apenas uma coluna do data frame nós perdemos a estrutura de data frame, pois uma coluna isoladamente se torna um vetor:

 66 class(caxg[, c("dap","h")])
 67 class(caxg$dap)
 68

Assim, é necessário forçar que a variável continue com a estrutura de data frame, utilizando o comando data.frame(mdap=caxg$dap) no lugar da variável agregante:

 69 cax.par.mdap = aggregate(data.frame(mdap=caxg$dap),
 70                          list(parcela=caxg$parcela, local=caxg$local),
 71                          mean)
 72 cax.par.mdap
 73

5.4.4. Agregação de Listas


Embora seja menos frequente se armazenar e organizar os dados na forma de lista, às vezes ocorre que é necessário aplicar uma ou várias funções aos diferentes elementos de uma lista. Para realizar essa operação existem várias funções, mas primeiramente vamos criar uma lista a partir de 10 observações aleatórias das árvores de caixeta:

 74 # 5.4.4. Agregação de Listas
 75
 76 ## Criando uma Lista
 77 tmp = cax[ sample(1:dim(cax)[1], 10), -1 ]
 78 caxl <- as.list(tmp)
 79 caxl
 80 caxl$especie <- caxl$especie == "Tabebuia cassinoides"
 81 caxl
 82

O objeto caxl é uma lista contendo 10 árvores de caixeta selecionadas aleatoriamente do “data frame” cax.

Função 'lapply'

A função lapply aplica uma dada função qualquer de summarização de dados aos vários elementos de uma lista.

 83 ## Função 'lapply'
 84 lapply(caxl, mean)
 85 lapply(caxl, sd)
 86 lapply(caxl, median)
 87 lapply(caxl, fivenum)
 88 lapply(caxl, quantile, probs=c(0.25,0.5,0.75))
 89

O objeto que ela retorna é também da classe list:

 
 90 class(lapply(caxl, median))
 91 class(lapply(caxl, fivenum))
 92

Função 'sapply'

A função sapply realiza a mesma operação, mas ela “simplifica” o objeto resultante, transformando-o num vetor ou numa matriz:

 93 ## Função 'sapply'
 94 sapply(caxl, mean)
 95 sapply(caxl, sd)
 96 sapply(caxl, median)
 97 sapply(caxl, fivenum)
 98 sapply(caxl, quantile, probs=c(0.25,0.5,0.75))
 99
100 class(sapply(caxl, median))
101 class(sapply(caxl, fivenum))
102
103 dimnames(sapply(caxl, fivenum))
104 dimnames(sapply(caxl, quantile, probs=c(0.25,0.5,0.75)))
105

Função 'vapply'

Uma outra função para realizar essa mesma operação é a função vapply. Essa função além dois dois argumentos das funções anteriores (a lista e a função a ser aplicada), ela exige um terceiro argumento que pré-define o tipo de resultado que a função deve gerar:

106 ## Função 'vapply'
107 vapply(caxl, mean, c(Mean = 0))
108 vapply(caxl, fivenum,
109        c(Min. = 0, "1st Qu." = 0, Median=0, "3rd Qu." =0, Max. = 0 ))
110 vapply(caxl, quantile, c(0, 0, 0), probs=c(0.25,0.5,0.75))
111

Assim como a função sapply, a função vapply também “simplifica” o objeto resultante para um vetor ou matriz. Mas, no caso de uma matriz, ela utiliza os nomes do valores pré-definidos para nomear as linhas da matrix resultante.




lcf5876/historico-disciplina/2018/programa/05-operacoes-objetos-dados/05-04-agregacao.txt · Última modificação: 2020/03/06 09:26 por joaoluis