Extrakt Zeile entsprechenden minimalen Wert einer Variablen, der durch die Gruppe

Möchte ich (1) - Gruppe-Daten von einer variable (State), (2) innerhalb jeder Gruppe finden, die die Reihe von minimum-Wert der anderen variable (Employees), und (3) extrahieren Sie die gesamte Zeile.

(1) und (2) sind einfache Einzeiler, und ich fühle mich wie (3) sollten das auch sein, aber ich kann es nicht bekommen.

Hier ist ein Beispiel-Datensatz:

> 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))

Berechnen min von der Gruppe ist einfach, mit aggregate:

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

...oder data.table:

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

Aber wie extrahiere ich die gesamte Zeile entsprechend min Werte, also auch Company im Ergebnis?

InformationsquelleAutor Ed Swindelles | 2014-06-05

46

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

   State Company Employees
1:    AK       D        24
2:    RI       E        19
```
Geringfügig weniger elegant als mit .SD, aber ein bisschen schneller (für Daten mit vielen Gruppen):
```
DT[DT[ , .I[which.min(Employees)], by = State]$V1]
```
Auch, nur ersetzen Sie den Ausdruck which.min(Employees) mit Employees == min(Employees) wenn ein Daten-set hat mehrere identische min-Werte, und Sie möchten Teilmenge alle von Ihnen.

Siehe auch Teilmenge von Gruppe mit Daten.Tabelle.

Wie um es zu bekommen, wenn die Zahl zurückgeben sollte, das minimum, aber basierend auf der Anzahl der Häufigkeit, die Zahl wurde verwendet?

InformationsquelleAutor Señor O

Einen dplyr Lösung :

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

InformationsquelleAutor agstudy

Als dies ist die Google-top-Treffer, ich dachte, ich möchte hinzufügen, einige zusätzliche Optionen, die ich nützlich finde zu wissen. Die Idee ist grundsätzlich zu vereinbaren, sobald durch Employees und dann nur die uniques pro State

Entweder mit data.table

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

Alternativ könnten wir auch die erste Bestellung und dann Teilmenge .SD. Diese beiden Operationen optimiert wurden in den letzten Daten.Tabelle Versionen und order ist scheinbar löst data.table:::forderv, während .SD[1L] löst 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

Oder dplyr

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

Andere interessante Idee entlehnt @Khashaas genial Antwort (mit einer kleinen Modifikation in form von mult = "first" um mehrere übereinstimmungen) ist zunächst die Suche nach minimum pro Gruppe und führen Sie dann eine binäre Verknüpfung zurück. Der Vorteil hierbei ist sowohl die Nutzung der Daten.Tabellen gmin - Funktion (die überspringt die Auswertung overhead) und die binäre join Funktion

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

Einige benchmarks

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

Schön gemacht. Nur der Vollständigkeit halber / Neugier, habe ich eine richtige plyr Lösung. Fühlen Sie sich frei, um in benchmark... ich erwarte nicht, dass Sie stehen wird bis zu data.table obwohl.
Aktualisiert.

InformationsquelleAutor David Arenburg

7

Die Basis-Funktion by ist oft nützlich für die Arbeit mit block-Daten in Daten.frames. Zum Beispiel
```
by(data, data$State, function(x) x[which.min(x$Employees), ] )
```
Tut es die Daten zurück, die in einer Liste, aber Sie kann zusammenbrechen, mit
```
do.call(rbind, by(data, data$State, function(x) x[which.min(x$Employees), ] ))
```
InformationsquelleAutor MrFlick

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.