dplyr - à l'aide de muter() comme rowmeans()

Je ne trouve la réponse nulle part.

Je voudrais calculer une nouvelle variable de bloc de données qui est basée sur la moyenne des lignes.

Par exemple:

data <- data.frame(id=c(101,102,103), a=c(1,2,3), b=c(2,2,2), c=c(3,3,3))

Je veux utiliser muter pour faire de la variable d qui est la moyenne de a,b et c. Et je voudrais être en mesure de les mettre en sélectionnant les colonnes de la manière d=mean(a,b,c), et aussi j'ai besoin d'utiliser la gamme de variables (comme dans dplyr) d=mean(a:c).

Et bien sûr

mutate(data, c=mean(a,b))

mutate(data, c=rowMeans(a,b))

ne fonctionne pas.

Pouvez-vous me donner quelques conseil?

Ce qui concerne

rowMeans est pour une matrice, pas un vecteur de args. Je vous suggère de data %>% mutate(c = Reduce("+",.)/length(.))
Merci ça fonctionne, mais comment choisir uniquement des lignes spécifiques (par ex. p1 à p32)? Et la façon de traiter avec NAs?
Pourriez-vous modifier votre question pour illustrer ce que tu veux dire?
Ok, je l'ai fait. Il est clair maintenant? 😉

InformationsquelleAutor Tomasz Wojtas | 2015-10-28

dplyr r

30

Vous êtes à la recherche pour
```
data %>% 
    rowwise() %>% 
    mutate(c=mean(c(a,b)))

#      id     a     b     c
#   (dbl) (dbl) (dbl) (dbl)
# 1   101     1     2   1.5
# 2   102     2     2   2.0
# 3   103     3     2   2.5
```
ou
```
library(purrr)
data %>% 
    rowwise() %>% 
    mutate(c=lift_vd(mean)(a,b))
```
- Ah. Pas mal du tout. Malheureusement, la documentation de rowwise est terrible (“rowwise fait quelque chose dans certaines situations. Voici un undescriptive exemple pour un seul cas particulier qui ne peut pas être généralisée.”) aussi, je finis par ne jamais l'utiliser. 🙁
InformationsquelleAutor Matthew Plourde
13

dplyr est mal adaptée pour fonctionner sur ce type de données car il suppose bien rangé données format et — pour le problème en question de vos données est en désordre.

Bien sûr, vous pouvez la ranger première:
```
tidy_data = tidyr::gather(data, name, value, -id)
```
Qui ressemble à ceci:
```
   id name value
1 101    a     1
2 102    a     2
3 103    a     3
4 101    b     2
5 102    b     2
6 103    b     2
    …
```
Et puis:
```
tidy_data %>% group_by(id) %>% summarize(mean = mean(value))
```
```
    name  mean
  (fctr) (dbl)
1      a     2
2      b     2
3      c     3
```
Bien sûr, cela annule les données d'origine. Vous pouvez utiliser mutate au lieu de summarize pour éviter cela. Enfin, vous pouvez ensuite onu-rangez vos données:
```
tidy_data %>%
    group_by(id) %>%
    mutate(mean = mean(value)) %>%
    tidyr::spread(name, value)
```
```
     id     mean     a     b     c
  (dbl)    (dbl) (dbl) (dbl) (dbl)
1   101 2.000000     1     2     3
2   102 2.333333     2     2     3
3   103 2.666667     3     2     3
```
Alternativement, vous pourriez résumer et puis fusionner le résultat avec la table d'origine:
```
tidy_data %>%
    group_by(id) %>%
    summarize(mean = mean(value)) %>%
    inner_join(data, by = 'id')
```
Le résultat est le même dans les deux cas. Je conceptuellement préfère la deuxième variante.
- D'ailleurs: la restructuration de données peut être inefficace pour les très grandes tables mais j'ai utiliser le code équivalent avec une base de données.cadre qui a plusieurs millions de lignes, et il fonctionne toujours très bien.
- J'ai oublié que pour dplyr de données devrait être de l'ordre, mais en fait, pour ma part ce genre de transformation semble être très oblique de la sorte... Mais maintenant j'ai compris! 🙂
- Il me semble que l'OP question a plus à voir avec mean.default's maladroit signature (points après les paramètres par défaut), l'interaction avec dplyr'argument de la cartographie de dplyr's de l'incapacité à travailler avec "désordre" des données.
InformationsquelleAutor Konrad Rudolph
5

Une simple possibilité, avec peu de code est:
```
data %>%
    mutate(c= rowMeans(data.frame(a,b)))

 #     id a b   c
 #  1 101 1 2 1.5
 #  2 102 2 2 2.0
 #  3 103 3 2 2.5
```
Comme rowMeans besoin de quelque chose comme une matrice ou un data.châssis, vous pouvez utiliser data.frame(var1, var2, ...) au lieu de c(var1, var2, ...). Si vous avez des NAs à vos données vous aurez besoin de dire R que faire, par exemple pour les supprimer: rowMeans(data.frame(a,b), na.rm=TRUE)

InformationsquelleAutor j_5chneider
5

Et encore un autre couple de façons, utile si vous avez le numérique positions ou vecteur noms des colonnes résumé:
```
data %>% mutate(d = rowMeans(.[, 2:4]))
```
ou
```
data %>% mutate(d = rowMeans(.[, c("a","b","c")]))
```
- assez similaire à ma réponse, mais j'aime la façon dont vous n'avez pas besoin d'utiliser data.frame() ce genre de m'a toujours agacé. merci.
- c'est la meilleure solution, mais plus simple à l'aide de select sur l'ambiance dans le bloc de données. Ont ajouté une réponse.
InformationsquelleAutor JWilliman

Je pense que c'est le dplyr-ish sorte. Tout d'abord, je voudrais créer une fonction:

my_rowmeans = function(...) Reduce(`+`, list(...))/length(list(...))

Ensuite, il peut être utilisé à l'intérieur de muter:

data %>% mutate(rms = my_rowmeans(a, b))

#    id a b c rms
# 1 101 1 2 3 1.5
# 2 102 2 2 3 2.0
# 3 103 3 2 3 2.5

# or

data %>% mutate(rms = my_rowmeans(a, b, c))

#    id a b c      rms
# 1 101 1 2 3 2.000000
# 2 102 2 2 3 2.333333
# 3 103 3 2 3 2.666667

Pour faire face à la possibilité de NAs, la fonction doit être uglified:

my_rowmeans = function(..., na.rm=TRUE){
  x = 
    if (na.rm) lapply(list(...), function(x) replace(x, is.na(x), as(0, class(x)))) 
    else       list(...)

  d = Reduce(function(x,y) x+!is.na(y), list(...), init=0)

  Reduce(`+`, x)/d
} 

# alternately...

my_rowmeans2 = function(..., na.rm=TRUE) rowMeans(cbind(...), na.rm=na.rm)

# new example

data$b[2] <- NA  
data %>% mutate(rms = my_rowmeans(a,b,na.rm=FALSE))

   id a  b c rms
1 101 1  2 3 1.5
2 102 2 NA 3  NA
3 103 3  2 3 2.5

data %>% mutate(rms = my_rowmeans(a,b))

   id a  b c rms
1 101 1  2 3 1.5
2 102 2 NA 3 2.0
3 103 3  2 3 2.5

La baisse de la my_rowmeans2 est qu'il contraint à une matrice. Je ne suis pas certain que ce sera toujours plus lent que le Reduce approche, si.

my_rowmeans = fonction(...) Réduire(+, liste(...))/longueur(liste (...) il est très proche de la solution de mon problème. Mais la façon de traiter avec NAs? na.rm paramètre serait très utile 😉
Mis à jour. Il serait mieux si votre post initial reflète aussi (plutôt que de l'étendre à la question dans les commentaires).

InformationsquelleAutor Frank

4

Je pense que la réponse suggérant à l'aide de data.frame ou à découper sur . est le meilleur, mais pourrait être rendu plus simple et plus dplyr-ish comme suit:
```
data %>% mutate(c = rowMeans(select(., a,b)))
```
Ou si vous voulez éviter de ., avec la peine d'avoir deux entrées à votre pipeline:
```
data %>% mutate(c = rowMeans(select(data, a,b)))
```
- Oui. L'utilisation de select augmentation de la flexibilité pour le choix des variables pour être additionnées.
InformationsquelleAutor bjw

Vous devez vous connecter pour publier un commentaire.