filtrage à l'aide de plusieurs conditions sur plusieurs colonnes à l'aide de dplyr

J'ai cherché sur DONC essayer de trouver une solution en vain. Si elle est ici. J'ai un bloc de données avec de nombreuses colonnes, dont certaines sont numériques et ne doit pas être négative. Je veux nettoyer les données depuis quelques valeurs dans ces numérique colonnes sont négatifs. Ce que je peux faire maintenant est d'extraire les noms de colonnes de ces colonnes avec une expression régulière. Mais je ne suis pas sûr de la façon de mettre en œuvre le filtrage de lignes sur la base de ces colonnes.

Pour donner un exemple, nous allons dire:

library(dplyr)
df <- read.table(text = 
  "id   sth1    tg1_num   sth2    tg2_num    others   
  1     dave    2         ca      35         new
  2     tom     5         tn      -3         old
  3     jane    -3        al       0         new
  4     leroy   0         az      25         old
  5     jerry   4         mi      55        old", header=TRUE)
pattern <- "_num$"
ind <- grep(pattern, colnames(df))
target_columns <- colnames(df)[ind]
df <- df %>% filter(target_columns >= 0) # it's is wrong, but it's what I want to do

Ce que je veux sortir de ce filtrage est la suivante:

id   sth1 tg1_num   sth2 tg2_num others
1    dave       2     ca      35    new
4   leroy       0     az      25    old
5   jerry       4     mi      55    old

où les lignes ne. 2 et 3 ne sont pas filtrées, parce que au moins une colonne en tg1_num et tg2_num pour ces lignes contiennent des nombres négatifs.

df %>%select(matches("_num$"))?
Qu'est-ce que le résultat désiré? Voulez-vous le dos ou tout simplement celles correspondant au modèle? Voulez-vous les deux colonnes à être plus grande ou égale à zéro, ou un seul suffit? Merci de nous montrer le produit final
c'est une façon de sélectionner les colonnes cibles. Mais ne résout pas mon problème

OriginalL'auteur breezymri | 2015-08-19

  1. 4

    C'est un très maladroit utilisation de dplyr, mais peut-être fidèle à l'esprit

    > df %>% mutate(m = do.call(pmin, select(df, ends_with("_num"))))
  id  sth1 tg1_num sth2 tg2_num others  m
1  1  dave       2   ca      35    new  2
2  2   tom       5   tn      -3    old -3
3  3  jane      -3   al       0    new -3
4  4 leroy       0   az      25    old  0
5  5 jerry       4   mi      55    old  4

    À partir de là, vous pouvez ajouter un filter(m >= 0) pour obtenir la réponse que vous voulez. Si il y avait un rowMins analogue à rowMeans alors ce serait simplifier de manière significative.

    > rowMins <- function(df) { do.call(pmin, df) }
> df %>% mutate(m = rowMins(select(df, ends_with("_num"))))
  id  sth1 tg1_num sth2 tg2_num others  m
1  1  dave       2   ca      35    new  2
2  2   tom       5   tn      -3    old -3
3  3  jane      -3   al       0    new -3
4  4 leroy       0   az      25    old  0
5  5 jerry       4   mi      55    old  4

    Je ne sais pas comment efficace, c'est, bien. Et l'imbrication de la select semble réel laid.

    EDIT3: en Utilisant les idées chipé à partir d'autres solutions/commentaires (h/t @Vlo) je peux la vitesse de la mine de beaucoup (malheureusement, une telle optimisation des vitesses allant jusqu' @Vlo de solution encore plus (EDIT4: Oups, mal lu le tableau, je suis le plus rapide, ok, pas plus à ce sujet))

    df %>% select(ends_with("_num")) %>% rowMins %>% {df[. >= 0,]}

    EDIT: par curiosité, certains n'ont microbenchmarking sur certaines des solutions (EDIT2: Ajout de solutions)

    microbenchmark(rowmins(df), rowmins2(df), reducer(df), sapplyer(df), grepapply(df), tchotchke(df), withrowsums(df), reducer2(df))

Unit: microseconds
            expr       min         lq      mean    median        uq       max
     rowmins(df)  1373.452  1431.9700  1732.188  1576.043  1729.410  5147.847
    rowmins2(df)   836.885   875.9900  1015.364   913.285  1038.729  2510.339
     reducer(df)   990.096  1058.6645  1217.264  1201.159  1297.997  3103.809
    sapplyer(df) 14119.236 14939.8755 16820.701 15952.057 16612.709 66023.721
   grepapply(df) 12907.657 13686.2325 14517.140 14485.520 15146.294 17291.779
   tchotchke(df)  2770.818  2939.6425  3114.233  3036.926  3172.325  4098.161
 withrowsums(df)  1526.227  1627.8185  1819.220  1722.430  1876.360  3025.095
    reducer2(df)   900.524   943.1265  1087.025  1003.820  1109.188  3869.993

    Et voici les définitions que j'ai utilisé

    rowmins <- function(df) {
df %>%
mutate(m = rowMins(select(df, ends_with("_num")))) %>%
filter(m >= 0) %>%
select(-m)
}
rowmins2 <- function(df) {
df %>% select(ends_with("_num")) %>% rowMins %>% {df[. >= 0,]}
}
reducer <- function(df) {
df %>%
select(matches("_num$")) %>%
lapply(">=", 0) %>%
Reduce(f = "&", .) %>%
which %>%
slice(.data = df)
}
reducer2 <- function(df) {
df %>%
select(matches("_num$")) %>%
lapply(">=", 0) %>%
Reduce(f = "&", .) %>%
{df[.,]}
}
sapplyer <- function(df) {
nums <- sapply(df, is.numeric)
df[apply(df[, nums], MARGIN=1, function(x) all(x >= 0)), ]
}
grepapply <- function(df) {
cond <- df[, grepl("_num$", colnames(df))] >= 0
df[apply(cond, 1, function(x) {prod(x) == 1}), ]
}
tchotchke <- function(df) {
pattern <- "_num$"
ind <- grep(pattern, colnames(df))
target_columns <- colnames(df)[ind]
desired_rows <- sapply(target_columns, function(x) which(df[,x]<0), simplify=TRUE)
as.vector(unique(unlist(desired_rows)))
}
withrowsums <- function(df) {
df %>% mutate(m=rowSums(select(df, ends_with("_num"))>0)) %>% filter(m==2) %>% select(-m)
}
df <- data.frame(id=1:10000, sth1=sample(LETTERS, 10000, replace=T), tg1_num=runif(10000,-1,1), tg2_num=runif(10000,-1, 1))
    Vérifier celui-ci dehors. df doit contenir le négatif et le positif entier (pas de petites décimales) des valeurs comme l'OP de l'échantillon de données. superreducer <- function(df) { df %>% select(matches("_num$")) %>% Reduce(bitwOr, .) %>% {.>=0L} %>% which %>% slice(.data = df) } est 20% plus rapide que reducer()
    Quel est le sens de l'accolades autour de {df[. >= 0,]}?
    C'est un magrittr caprice; si vous exécutez une pipe à un bloc anonyme (c'est à dire entre accolades) le résultat de la commande précédente est stocké dans . -- 3 %>% { . + 1 } rendements 4. C'est donc dire filtre pour toutes les lignes où l'élément précédent est supérieur à zéro.

    OriginalL'auteur user295691

  2. 6

    Voici une possible vectorisé solution

    ind <- grep("_num$", colnames(df))
df[!rowSums(df[ind] < 0),]
#   id  sth1 tg1_num sth2 tg2_num others
# 1  1  dave       2   ca      35    new
# 4  4 leroy       0   az      25    old
# 5  5 jerry       4   mi      55    old

    L'idée ici est de créer une logique de la matrice à l'aide de la < fonction (c'est une fonction générique qui a data.frame méthode, ce qui signifie qu'il retourne d'un bloc de données comme la structure à l'arrière). Ensuite, nous utilisons rowSums à trouver si il y avait un d'eux correspond à des conditions (> 0 - correspondance, 0 - non appariés). Ensuite, nous utilisons le ! fonction, afin de le convertir à une logique de vecteur: >0 devient TRUE, tandis que 0 devient FALSE. Enfin, nous sommes. en fonction de ce vecteur.

    Merci. C'est une bonne et intuitive de la solution. J'ai accepté la réponse de @user295691 parce que je pense que sa réponse est complète. L'utilisation de rowMins est aussi probablement plus rapide que l'utilisation de rowSums.

    OriginalL'auteur David Arenburg

  3. 4

    Je voulais voir ce qui a été possible en utilisant la norme d'évaluation avec dplyr de filter_. Il s'avère qu'il peut être fait avec l'aide de interp de lazyeval, à la suite de la exemple de code sur cette page. Essentiellement, vous devez créer une liste de la interp conditions qui vous passent ensuite au .dots argument de filter_.

    library(lazyeval)
dots <- lapply(target_columns, function(cols){
interp(~y >= 0, .values = list(y = as.name(cols)))
})
filter_(df, .dots = dots)   
id  sth1 tg1_num sth2 tg2_num others
1  1  dave       2   ca      35    new
2  4 leroy       0   az      25    old
3  5 jerry       4   mi      55    old

    Mise à jour

    De départ avec dplyr_0.7, ce qui peut être fait directement avec filter_at et all_vars (pas de lazyeval nécessaire).

    df %>%
filter_at(vars(target_columns), all_vars(. >= 0) )
id  sth1 tg1_num sth2 tg2_num others
1  1  dave       2   ca      35    new
2  4 leroy       0   az      25    old
3  5 jerry       4   mi      55    old

    OriginalL'auteur aosmith

  4. 1

    À l'aide de la base de R pour obtenir votre résultat

    cond <- df[, grepl("_num$", colnames(df))] >= 0
df[apply(cond, 1, function(x) {prod(x) == 1}), ]
id  sth1 tg1_num sth2 tg2_num others
1  1  dave       2   ca      35    new
4  4 leroy       0   az      25    old
5  5 jerry       4   mi      55    old

    Edit: cela suppose que vous avez plusieurs colonnes avec "_num". Il ne fonctionnera pas si vous avez juste un _num colonne

    OriginalL'auteur Whitebeard

  5. 1

    Nous avons d'abord créer un index de toutes les colonnes numériques. Ensuite, nous sous-ensemble de toutes les colonnes d'une plus grande ou égale à zéro. Donc, il n'est pas nécessaire de vérifier les noms de colonne et la colonne id sera toujours positif.

    nums <- sapply(df, is.numeric)
df[apply(df[, nums], MARGIN = 1, function(x) all(x >= 0)), ]

    De sortie:

      id  sth1 tg1_num sth2 tg2_num others
1  1  dave       2   ca      35    new
4  4 leroy       0   az      25    old
5  5 jerry       4   mi      55    old

    OriginalL'auteur mpalanco

  6. 1

    Voici mon laid solution. Suggestions/critiques bienvenue

    df %>% 
# Select the columns we want
select(matches("_num$")) %>%
# Convert every column to logical if >= 0
lapply(">=", 0) %>%
# Reduce all the sublist with AND 
Reduce(f = "&", .) %>%
# Convert the one vector of logical into numeric
# index since slice can't deal with logical. 
# Can simply write `{df[.,]}` here instead,
# which is probably faster than which + slice
# Edit: This is not true. which + slice is faster than `[` in this case
which %>%
slice(.data = df)
id  sth1 tg1_num sth2 tg2_num others
1  1  dave       2   ca      35    new
2  4 leroy       0   az      25    old
3  5 jerry       4   mi      55    old
    Semble que ce soit la manière la plus rapide proposée jusqu'à présent; quelques repères ci-dessous dans ma réponse.
    Nvm, qui ressemble + tranche de beats sur la base de sous-ensemble de R par une très importante marge

    OriginalL'auteur Vlo

  7. 0

    Cela vous donnera un vecteur de lignes qui sont inférieures à 0:

    desired_rows <- sapply(target_columns, function(x) which(df[,x]<0), simplify=TRUE)
desired_rows <- as.vector(unique(unlist(desired_rows)))

    Alors d'obtenir un df de votre choix à l'lignes:

    setdiff(df, df[desired_rows,])
id  sth1 tg1_num sth2 tg2_num others
1  1  dave       2   ca      35    new
2  4 leroy       0   az      25    old
3  5 jerry       4   mi      55    old
    Cela ressemble à fonctionner. Cependant, je tiens à éviter à l'aide de boucles. Mes données est assez grand et il sera donc probablement très lent.
    mis à jour pour utiliser les appliquer
    Juste par intérêt, pensez-vous que l'on pouvait aussi utiliser filter(...) dans votre première ligne de code?

    OriginalL'auteur Tchotchke