studio - superponer graficas en r

Extraiga la fila correspondiente al valor mínimo de una variable por grupo

Question

Deseo (1) agrupar los datos por una variable ( State ), (2) dentro de cada grupo encontrar la fila del valor mínimo de otra variable ( Employees ), y (3) extraer la fila completa.

(1) y (2) son fáciles de entender, y siento que (3) debería serlo también, pero no puedo obtenerlo.

Aquí hay un conjunto de datos de muestra:

> data
  State Company Employees
1    AK       A        82
2    AK       B       104
3    AK       C        37
4    AK       D        24
5    RI       E        19
6    RI       F       118
7    RI       G        88
8    RI       H        42

data <- structure(list(State = structure(c(1L, 1L, 1L, 1L, 2L, 2L, 2L, 
        2L), .Label = c("AK", "RI"), class = "factor"), Company = structure(1:8, .Label = c("A", 
        "B", "C", "D", "E", "F", "G", "H"), class = "factor"), Employees = c(82L, 
        104L, 37L, 24L, 19L, 118L, 88L, 42L)), .Names = c("State", "Company", 
        "Employees"), class = "data.frame", row.names = c(NA, -8L))

Calcular min por grupo es fácil, usando aggregate :

> aggregate(Employees ~ State, data, function(x) min(x))
  State Employees
1    AK        24
2    RI        19

... o data.table :

> library(data.table)
> DT <- data.table(data)
> DT[ , list(Employees = min(Employees)), by = State]
   State Employees
1:    AK        24
2:    RI        19

Pero, ¿cómo extraigo toda la fila correspondiente a estos valores mínimos, es decir, también incluyo a la Company en el resultado?

Answer 1

Como este es el éxito principal de Google, pensé que agregaría algunas opciones adicionales que me resultan útiles. La idea es básicamente organizar una vez por Employees y luego simplemente tomar los únicos por State

Ya sea usando data.table

library(data.table)
unique(setDT(data)[order(Employees)], by = "State")
#    State Company Employees
# 1:    RI       E        19
# 2:    AK       D        24

Alternativamente, también podríamos ordenar primero y luego subconjunto .SD . Ambas operaciones se optimizaron en las versiones reenviadas de data.table y el order aparentemente desencadena data.table:::forderv , mientras que .SD[1L] desencadena Gforce

setDT(data)[order(Employees), .SD[1L], by = State, verbose = TRUE] # <- Added verbose
# order optimisation is on, i changed from ''order(...)'' to ''forder(DT, ...)''.
# i clause present and columns used in by detected, only these subset: State 
# Finding groups using forderv ... 0 sec
# Finding group sizes from the positions (can be avoided to save RAM) ... 0 sec
# Getting back original order ... 0 sec
# lapply optimization changed j from ''.SD[1L]'' to ''list(Company[1L], Employees[1L])''
# GForce optimized j to ''list(`g[`(Company, 1L), `g[`(Employees, 1L))''
# Making each group and running j (GForce TRUE) ... 0 secs
#    State Company Employees
# 1:    RI       E        19
# 2:    AK       D        24

O dplyr

library(dplyr)
data %>% 
  arrange(Employees) %>% 
  distinct(State, .keep_all = TRUE)
#   State Company Employees
# 1    RI       E        19
# 2    AK       D        24

Otra idea interesante tomada de @Khashaas awesome answer (con una pequeña modificación en forma de mult = "first" para manejar múltiples coincidencias) es encontrar primero el mínimo por grupo y luego realizar una vuelta binaria. La ventaja de esto es tanto la utilización de la función data.tables gmin (que omite la sobrecarga de evaluación) como la función de combinación binaria

tmp <- setDT(data)[, .(Employees = min(Employees)), by = State]
data[tmp, on = .(State, Employees), mult = "first"]
#    State Company Employees
# 1:    AK       D        24
# 2:    RI       E        19

Algunos puntos de referencia

library(data.table)
library(dplyr)
library(plyr)
library(stringi)
library(microbenchmark)

set.seed(123)
N <- 1e6
data <- data.frame(State = stri_rand_strings(N, 2, ''[A-Z]''),
                   Employees = sample(N*10, N, replace = TRUE))
DT <- copy(data)
setDT(DT)
DT2 <- copy(DT)
str(DT)
str(DT2)

microbenchmark("(data.table) .SD[which.min]: " = DT[ , .SD[which.min(Employees)], by = State],
               "(data.table) .I[which.min]: " = DT[DT[ , .I[which.min(Employees)], by = State]$V1],
               "(data.table) order/unique: " = unique(DT[order(Employees)], by = "State"),
               "(data.table) order/.SD[1L]: " = DT[order(Employees), .SD[1L], by = State],
               "(data.table) self join (on):" = {
                 tmp <- DT[, .(Employees = min(Employees)), by = State]
                 DT[tmp, on = .(State, Employees), mult = "first"]},
               "(data.table) self join (setkey):" = {
                 tmp <- DT2[, .(Employees = min(Employees)), by = State] 
                 setkey(tmp, State, Employees)
                 setkey(DT2, State, Employees)
                 DT2[tmp, mult = "first"]},
               "(dplyr) slice(which.min): " = data %>% group_by(State) %>% slice(which.min(Employees)),
               "(dplyr) arrange/distinct: " = data %>% arrange(Employees) %>% distinct(State, .keep_all = TRUE),
               "(dplyr) arrange/group_by/slice: " = data %>% arrange(Employees) %>% group_by(State) %>% slice(1),
               "(plyr) ddply/which.min: " = ddply(data, .(State), function(x) x[which.min(x$Employees),]),
               "(base) by: " = do.call(rbind, by(data, data$State, function(x) x[which.min(x$Employees), ])))


# Unit: milliseconds
#                             expr        min         lq       mean     median         uq       max neval      cld
#    (data.table) .SD[which.min]:   119.66086  125.49202  145.57369  129.61172  152.02872  267.5713   100    d    
#     (data.table) .I[which.min]:    12.84948   13.66673   19.51432   13.97584   15.17900  109.5438   100 a       
#      (data.table) order/unique:    52.91915   54.63989   64.39212   59.15254   61.71133  177.1248   100  b      
#     (data.table) order/.SD[1L]:    51.41872   53.22794   58.17123   55.00228   59.00966  145.0341   100  b      
#     (data.table) self join (on):   44.37256   45.67364   50.32378   46.24578   50.69411  137.4724   100  b      
# (data.table) self join (setkey):   14.30543   15.28924   18.63739   15.58667   16.01017  106.0069   100 a       
#       (dplyr) slice(which.min):    82.60453   83.64146   94.06307   84.82078   90.09772  186.0848   100   c     
#       (dplyr) arrange/distinct:   344.81603  360.09167  385.52661  379.55676  395.29463  491.3893   100     e   
# (dplyr) arrange/group_by/slice:   367.95924  383.52719  414.99081  397.93646  425.92478  557.9553   100      f  
#         (plyr) ddply/which.min:   506.55354  530.22569  568.99493  552.65068  601.04582  727.9248   100       g 
#                      (base) by:  1220.38286 1291.70601 1340.56985 1344.86291 1382.38067 1512.5377   100        h

Answer 2

La función base by es a menudo útil para trabajar con datos de bloque en data.frames. Por ejemplo

by(data, data$State, function(x) x[which.min(x$Employees), ] )

Devuelve los datos en una lista, pero puede colapsar eso con

do.call(rbind, by(data, data$State, function(x) x[which.min(x$Employees), ] ))

Answer 3

Un poco más elegante:

library(data.table)
DT[ , .SD[which.min(Employees)], by = State]

   State Company Employees
1:    AK       D        24
2:    RI       E        19

Un poco menos elegante que usar .SD , pero un poco más rápido (para datos con muchos grupos):

DT[DT[ , .I[which.min(Employees)], by = State]$V1]

Además, simplemente reemplace la expresión which.min(Employees) con Employees == min(Employees) , si su conjunto de datos tiene múltiples valores mínimos idénticos y desea subconjuntos de todos ellos.

Ver también Subconjunto por grupo con data.table .

Answer 4

Una solución dplyr :

library(dplyr)    
data %>% 
    group_by(State) %>% 
    slice(which.min(Employees))

Answer 5

plyr corregida de plyr :

ddply(df, .(State), function(x) x[which.min(x$Employees),])
#   State Company Employees
# 1    AK       D        24
# 2    RI       E        19

gracias a @ joel.wilson