dplyr filtre: Obtenir des lignes avec un minimum de variable, mais seulement la première si minima multiples

Je veux faire un groupe de filtre à l'aide de dplyr, de manière que, dans chaque groupe, seulement cette ligne est renvoyée, qui a la valeur minimale de la variable x.

Mon problème est le suivant: Comme prévu, dans le cas de plusieurs minima tous lignes avec la valeur minimale sont retournés. Mais dans mon cas, je veux seulement la première ligne si plusieurs minima sont présents.

Voici un exemple:

df <- data.frame(
A=c("A", "A", "A", "B", "B", "B", "C", "C", "C"),
x=c(1, 1, 2, 2, 3, 4, 5, 5, 5),
y=rnorm(9)
)

library(dplyr)
df.g <- group_by(df, A)
filter(df.g, x == min(x))

Comme prévu, tous les minima sont de retour:

Source: local data frame [6 x 3]
Groups: A

  A x           y
1 A 1 -1.04584335
2 A 1  0.97949399
3 B 2  0.79600971
4 C 5 -0.08655151
5 C 5  0.16649962
6 C 5 -0.05948012

Avec ddply, j'aurais approche de la tâche de cette façon:

library(plyr)
ddply(df, .(A), function(z) {
    z[z$x == min(z$x), ][1, ]
})

... qui fonctionne:

  A x           y
1 A 1 -1.04584335
2 B 2  0.79600971
3 C 5 -0.08655151

Q: Est-il une façon d'aborder cette question dans dplyr? (Pour des raisons de vitesse)

  • filter(df.g, rank(x) == 1) ?
  • Merci. Je savais qu'il y aurait une solution facile 😉
  • ne rank(x)==1 donner les résultats escomptés?
  • il nécessite ties=first argument. FelixS, si vous allez pour la vitesse, rank est une mauvaise idée de calcul de plus en plus exigeants que min (ou) which.min.
  • En fait, vous voulez probablement min_rank(). @Arun: dplyr fournit une mise en œuvre interne de min_rank() qui devrait être beaucoup assez rapide.
  • 1) je ne pense pas que min_rank aide ici. Il a besoin de la première valeur min (regardez plyr solution). 2) quel que soit le langage de programmation que vous écrivez, la complexité algorithmique de rank (liens=min, max, le premier, etc..) sera plus grand que juste l'informatique min.
  • prématuré d'optimisation est ...
  • pas de vous suivre.
  • Vrai, seulement rank(x, ties.method="first")==1 œuvres, comme min et min_rank ne font pas de distinction entre plusieurs minima.
  • la droite. Mais c'est assez cher (parce que c'est de trier toutes les valeurs pour chaque groupe). Vous devriez être en utilisant which.min. Mais je ne sais pas d'une dplyr solution. Un plyr cas serait: ddply(df, .(A), function(z) z[which.min(z$x), ])
  • c'est en supposant qu'un temps O(n lg n) algorithme effectuez beaucoup plus de mal qu'un algorithme O(n) sans plus d'informations sur le domaine
  • Désolé, j'étais en train de penser de row_number() - c'est l'équivalent de rank(ties = "first") mais être mis en œuvre de manière plus efficace en C++.
  • Je ne vois pas comment cela vous fait envisager which.min être prématuré d'optimisation. Autant que je sache, c'est un choix naturel, agréable à lire, facile à comprendre, rapide, comme il arrive à O(n) trop.

InformationsquelleAutor Felix S | 2014-01-23
  1. 83

    Mise à jour

    Avec dplyr >= 0.3, vous pouvez utiliser le slice fonction en combinaison avec which.min, qui serait mon approche préférée pour cette tâche:

    df %>% group_by(A) %>% slice(which.min(x))
#Source: local data frame [3 x 3]
#Groups: A
#
#  A x          y
#1 A 1  0.2979772
#2 B 2 -1.1265265
#3 C 5 -1.1952004

    Réponse originale à cette question

    Pour l'échantillon de données, il est également possible d'utiliser deux filter les uns après les autres:

    group_by(df, A) %>% 
  filter(x == min(x)) %>% 
  filter(1:n() == 1)
    • Je trouve do(head) plus facile à lire, df %>% group_by(A) %>% filter(x == min(x)) %>% do(head(.,1))
    • qui a l'air sympa en effet (cependant, quand je le lance, j'obtiens un message d'erreur Error: expecting a single value) - savez-vous pourquoi?
    • pas sûr, nous sommes peut-être en utilisant une version différente; j'ai dplyr_0.2, magrittr_1.0.0
    • Ok, donc le problème est que je suis toujours en cours de dplyr 0.1.3. Thx
    • Je préfère être en mesure d'utiliser top_n ici, mais en raison des liens de cette méthode est probablement le gagnant clair, certainement en termes de performance (par rapport à l' arrange %>% slice).
    InformationsquelleAutor docendo discimus
  2. 34

    Juste pour être complet: Voici la dernière dplyr solution, dérivée à partir des commentaires de @hadley et @Arun:

    library(dplyr)
df.g <- group_by(df, A)
filter(df.g, rank(x, ties.method="first")==1)
    InformationsquelleAutor Felix S
  3. 14

    Pour ce que ça vaut, voici un data.table solution, pour ceux qui pourraient être intéressés:

    # approach with setting keys
dt <- as.data.table(df)
setkey(dt, A,x)
dt[J(unique(A)), mult="first"]

# without using keys
dt <- as.data.table(df)
dt[dt[, .I[which.min(x)], by=A]$V1]
    InformationsquelleAutor Arun
  4. 4

    Ceci peut être accompli en utilisant row_number combiné avec group_by. row_number poignées des liens par l'attribution d'un grade non seulement par la valeur, mais aussi par l'ordre relatif dans le vecteur. Pour obtenir la première ligne de chaque groupe avec la valeur minimale de x:

    df.g <- group_by(df, A)
filter(df.g, row_number(x) == 1)

    Pour plus d'informations, voir la dplyr vignette sur les fonctions de la fenêtre.

    InformationsquelleAutor junkka
  5. 0

    J'aime sqldf pour sa simplicité..

    sqldf("select A,min(X),y from 'df.g' group by A")

    De sortie:

    A min(X)          y

1 A      1 -1.4836989

2 B      2  0.3755771

3 C      5  0.9284441
    InformationsquelleAutor nsr
  6. 0

    Une autre façon de faire:

    set.seed(1)
x <- data.frame(a = rep(1:2, each = 10), b = rnorm(20))
x <- dplyr::arrange(x, a, b)
dplyr::filter(x, !duplicated(a))

    Résultat:

      a          b
1 1 -0.8356286
2 2 -2.2146999

    Pourrait également être facilement adapté pour l'obtention de la ligne de chaque groupe avec une valeur maximale.

    InformationsquelleAutor qed
  7. 0

    Venu ici à la recherche d'un moyen de le faire avec plus d'un. Cela donnera à la partie inférieure de dix, rompre les liens de la dernière, je crois

    df.g %>%
top_n(-10,row_number(x))
    InformationsquelleAutor Kevin Mc