Fonctions d'agrégation en R : summarise() et group_by() Exemple

Jeu de données utilisé dans ce tutoriel

La synthèse d'une variable donne un premier aperçu des données, tandis que leur synthèse par groupe apporte des informations bien plus précises sur la distribution des valeurs. Ce tutoriel explique comment agréger un jeu de données par groupe à l'aide de la bibliothèque dplyr.

Ce tutoriel utilise l'ensemble de données de frappe de Lahman. Après l'avoir importé et conservéping Seules les neuf colonnes énumérées ci-dessous sont présentes ; le cadre de données de travail contient 104 324 observations et 9 variables :

• playerID : code d’identification du joueur. Facteur
• ID de l'année : année. Facteur
• teamID : équipe. facteur
• lgID : Ligue. Facteur : AA AL FL NL PL UA
• AB : Au bâton. Numérique
• G : Jeux : nombre de parties jouées par un joueur. Numérique
• R : Fonctionne. Numérique
• RH : circuits. Numérique
• SH : Le sacrifice frappe. Numérique

Avant d'effectuer une synthèse, vous effectuerez les étapes suivantes pour préparer les données :

• Étape 1 : Importer les données
• Étape 2 : Sélectionnez les variables pertinentes
• Étape 3 : Trier les données

library(dplyr)

# Step 1
data <- read.csv("https://raw.githubusercontent.com/guru99-edu/R-Programming/master/lahman-batting.csv") %>%

# Step 2
select(c(playerID, yearID, AB, teamID, lgID, G, R, HR, SH))  %>% 

# Step 3
arrange(playerID, teamID, yearID)

Une bonne pratique lorsque vous importez un ensemble de données consiste à utiliser la fonction glimpse() pour avoir une idée de la structure de l'ensemble de données.

# Structure of the data
glimpse(data)

Sortie :

Observations: 104,324
Variables: 9
$ playerID <fctr> aardsda01, aardsda01, aardsda01, aardsda01, aardsda01, a...
$ yearID   <int> 2015, 2008, 2007, 2006, 2012, 2013, 2009, 2010, 2004, 196...
$ AB       <int> 1, 1, 0, 2, 0, 0, 0, 0, 0, 603, 600, 606, 547, 516, 495, ...
$ teamID   <fctr> ATL, BOS, CHA, CHN, NYA, NYN, SEA, SEA, SFN, ATL, ATL, A...
$ lgID     <fctr> NL, AL, AL, NL, AL, NL, AL, AL, NL, NL, NL, NL, NL, NL, ...
$ G        <int> 33, 47, 25, 45, 1, 43, 73, 53, 11, 158, 155, 160, 147, 15...
$ R        <int> 0, 0, 0, 0, 0, 0, 0, 0, 0, 117, 113, 84, 100, 103, 95, 75...
$ HR       <int> 0, 0, 0, 0, 0, 0, 0, 0, 0, 44, 39, 29, 44, 38, 47, 34, 40...
$ SH       <int> 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, ...

résumer()

La syntaxe de summarise() est basique et cohérente avec les autres verbes inclus dans la bibliothèque dplyr.

summarise(df, variable_name=condition) 
arguments: 
- `df`: Dataset used to construct the summary statistics 
- `variable_name=condition`: Formula to create the new variable

Regardez le code ci-dessous :

summarise(data, mean_run =mean(R))

Code Explication

• summarise(data, Mean_run = Mean(R)) : crée une variable nommée Mean_run qui est la moyenne de la colonne exécutée à partir des données de l'ensemble de données.

Sortie :

##   mean_run
## 1 19.20114

Vous pouvez ajouter autant de variables que vous le souhaitez. Vous renvoyez la moyenne des parties jouées et la moyenne des sacrifices réussis.

summarise(data, mean_games = mean(G),
    mean_SH = mean(SH, na.rm = TRUE))

Code Explication

• Mean_SH = Mean(SH, na.rm = TRUE) : Résumez une deuxième variable. Vous définissez na.rm = TRUE car la colonne SH contient des observations manquantes.

Sortie :

##   mean_games  mean_SH
## 1   51.98361 2.340085

group_by() vs Sans group_by()

Utilisée seule, la fonction `summarise()` réduit l'ensemble du dataframe à une seule ligne, comme le montrent les exemples ci-dessus. Sa véritable puissance se révèle lorsqu'on y ajoute `group_by()` : déplyr La bibliothèque applique ensuite le même calcul séparément à chaque groupe et renvoie une ligne par groupe.

Notez que group_by fonctionne parfaitement avec tous les autres verbes (c'est-à-dire mutate(), filter(), arrange(), …).

Il est pratique d'utiliser l'opérateur de pipeline lorsque vous avez plusieurs étapes. Vous pouvez calculer le circuit moyen par ligue de baseball.

data %>%
	group_by(lgID) %>%
	summarise(mean_run = mean(HR))

Code Explication

• data : ensemble de données utilisé pour construire les statistiques récapitulatives
• group_by(lgID) : Diviser les données selon les valeurs de lgID avant de les synthétiser.
• résumer (mean_run = moyenne (HR)) : Calculer le circuit moyen

Sortie :

## 
# A tibble: 7 x 2
##     lgID  mean_run
##   <fctr>     <dbl>
## 1     AA 0.9166667
## 2     AL 3.1270988
## 3     FL 1.3131313
## 4     NL 2.8595953
## 5     PL 2.5789474
## 6     UA 0.6216216
## 7   <NA> 0.2867133	

Le pipe fonctionne également avec ggplot(), ce qui permet de traiter l'ensemble du processus, des données brutes au graphique final, en une seule instruction. Le code ci-dessous combine group_by(), summarise() et ggplot() pour afficher le nombre moyen de home runs par ligue sous forme de graphique à barres.

Vous effectuerez l'étape suivante :

• Étape 1 : Sélectionnez le bloc de données
• Étape 2 : Regrouper les données
• Étape 3 : Résumer les données
• Étape 4 : tracer les statistiques récapitulatives

library(ggplot2)
# Step 1
data %>% 
#Step 2
group_by(lgID) %>% 
#Step 3
summarise(mean_home_run = mean(HR)) %>% 
#Step 4
ggplot(aes(x = lgID, y = mean_home_run, fill = lgID)) +
    geom_bar(stat = "identity") +
    theme_classic() +
    labs(
        x = "baseball league",
        y = "Average home run",
        title = paste(
            "Example group_by() with summarise()"
        )
    )

Sortie :

Fonctions que vous pouvez utiliser dans summarise()

Le verbe summarise() est compatible avec presque toutes les fonctions de R. Voici une courte liste de fonctions utiles que vous pouvez utiliser avec summarise() :

Les sections ci-dessous présentent un exemple pour chaque fonction du tableau ci-dessus. Si vous débutez avec le pipe et les autres verbes, commencez par… Tutoriel sur la sélection, le filtrage et l'organisation.

Fonction basique

Dans l’exemple précédent, vous n’avez pas stocké la statistique récapitulative dans un bloc de données.

Vous pouvez générer un cadre de données à partir d'un résumé en deux étapes :

• Étape 1 : stocker la trame de données pour une utilisation ultérieure
• Étape 2 : Utiliser l'ensemble de données pour créer un tracé linéaire

Étape 1) Vous calculez le nombre moyen de matchs joués par année.

## Mean
ex1 <- data %>%
	group_by(yearID) %>%
	summarise(mean_game_year = mean(G))
head(ex1)

Code Explication

• La statistique récapitulative de l'ensemble de données au bâton est stockée dans la trame de données ex1.

Sortie :

## # A tibble: 6 x 2
##   yearID mean_game_year
##    <int>          <dbl>
## 1   1871       23.42308
## 2   1872       18.37931
## 3   1873       25.61538
## 4   1874       39.05263
## 5   1875       28.39535
## 6   1876       35.90625	

Étape 2) Vous affichez la statistique récapitulative avec un tracé linéaire et voyez la tendance.

# Plot the graph
ggplot(ex1, aes(x = yearID, y = mean_game_year)) +
    geom_line() +
    theme_classic() +
    labs(
        x = "Year",
        y = "Average games played",
        title = paste(
            "Average games played from 1871 to 2016"
        )
    )

Sortie :

Sous-ensemble

La fonction summarise() est compatible avec les sous-ensembles.

## Subsetting + Median
data %>%
group_by(lgID) %>%
summarise(median_at_bat_league = median(AB), 
	#Compute the median without the zero 
	median_at_bat_league_no_zero = median(AB[AB > 0]))

Code Explication

• median_at_bat_league_no_zero = median(AB[AB > 0]) : La variable AB contient des lots de 0. Vous pouvez comparer la médiane des au bâton variable avec et sans 0.

Sortie :

## # A tibble: 7 x 3
##     lgID median_at_bat_league median_at_bat_league_no_zero
##   <fctr>                <dbl>                        <dbl>
## 1     AA                  130                          131
## 2     AL                   38                           85
## 3     FL                   88                           97
## 4     NL                   56                           67
## 5     PL                  238                          238
## 6     UA                   35                           35
## 7   <NA>                  101                          101	

Somme

Une autre fonction utile pour agréger la variable est sum().

Vous pouvez vérifier quelles ligues ont le plus de circuits.

## Sum
data %>%
	group_by(lgID) %>%
	summarise(sum_homerun_league = sum(HR))

Sortie :

## # A tibble: 7 x 2
##     lgID sum_homerun_league
##   <fctr>              <int>
## 1     AA                341
## 2     AL              29426
## 3     FL                130
## 4     NL              29817
## 5     PL                 98
## 6     UA                 46
## 7   <NA>                 41	

L'écart-type

La répartition des données est calculée avec l'écart type ou sd() dans R.

# Spread
data %>%
	group_by(teamID) %>%
	summarise(sd_at_bat_league = sd(HR))

Sortie :

## # A tibble: 148 x 2
##    teamID sd_at_bat_league
##    <fctr>            <dbl>
##  1    ALT               NA
##  2    ANA        8.7816395
##  3    ARI        6.0765503
##  4    ATL        8.5363863
##  5    BAL        7.7350173
##  6    BFN        1.3645163
##  7    BFP        0.4472136
##  8    BL1        0.6992059
##  9    BL2        1.7106757
## 10    BL3        1.0000000
## # ... with 138 more rows		

L'écart en matière de coups de circuit varie considérablement d'une équipe à l'autre, et ALT renvoie NA car cette équipe ne possède qu'une seule ligne, donc aucun écart type ne peut être calculé.

Minimum et maximum

Vous pouvez accéder au minimum et au maximum d'un vecteur avec les fonctions min() et max().

Le code ci-dessous renvoie le nombre de matchs le plus bas et le plus élevé au cours d'une saison joués par un joueur.

# Min and max
data %>%
	group_by(playerID) %>%
	summarise(min_G = min(G),
    max_G = max(G))

Sortie :

## # A tibble: 10,395 x 3
##     playerID min_G max_G
##       <fctr>       <int>
##  1 aardsda01    53    73
##  2 aaronha01   120   156
##  3  aasedo01    24    66
##  4  abadfe01    18    18
##  5 abadijo01    11    11
##  6 abbated01     3   153
##  7 abbeybe01    11    11
##  8 abbeych01    80   132
##  9 abbotgl01     5    23
## 10 abbotji01    13    29
## # ... with 10,385 more rows

que vous avez

Il est toujours utile de compter les observations par groupe. En R, la fonction n() renvoie le nombre de lignes dans le groupe actuel.

Par exemple, le code ci-dessous calcule le nombre d'années jouées par chaque joueur.

# count observations
data %>%
	group_by(playerID) %>%
	summarise(number_year = n()) %>%
	arrange(desc(number_year))

Sortie :

## # A tibble: 10,395 x 2
##     playerID number_year
##       <fctr>       <int>
##  1 pennohe01          11
##  2 joosted01          10
##  3 mcguide01          10
##  4  rosepe01          10
##  5 davisha01           9
##  6 johnssi01           9
##  7  kaatji01           9
##  8 keelewi01           9
##  9 marshmi01           9
## 10 quirkja01           9
## # ... with 10,385 more rows

Premier et dernier

Vous pouvez sélectionner la première, la dernière ou la nième position d'un groupe.

Par exemple, vous pouvez retrouver la première et la dernière année de chaque joueur.

# first and last
data %>%
	group_by(playerID) %>%
	summarise(first_appearance = first(yearID),
		last_appearance = last(yearID))

Sortie :

## # A tibble: 10,395 x 3
##     playerID first_appearance last_appearance
##       <fctr>            <int>           <int>
##  1 aardsda01             2009            2010
##  2 aaronha01             1973            1975
##  3  aasedo01             1986            1990
##  4  abadfe01             2016            2016
##  5 abadijo01             1875            1875
##  6 abbated01             1905            1897
##  7 abbeybe01             1894            1894
##  8 abbeych01             1895            1897
##  9 abbotgl01             1973            1979
## 10 abbotji01             1992            1996
## # ... with 10,385 more rows

nième observation

La fonction nth() complète first() et last(). Elle renvoie l'observation à l'index spécifié au sein de chaque groupe.

Par exemple, vous pouvez filtrer uniquement la deuxième année au cours de laquelle une équipe a joué.

# nth
data %>%
	group_by(teamID) %>%
	summarise(second_game = nth(yearID, 2)) %>%
	arrange(second_game)

Sortie :

## # A tibble: 148 x 2
##    teamID second_game
##    <fctr>       <int>
##  1    BS1        1871
##  2    CH1        1871
##  3    FW1        1871
##  4    NY2        1871
##  5    RC1        1871
##  6    BR1        1872
##  7    BR2        1872
##  8    CL1        1872
##  9    MID        1872
## 10    TRO        1872
## # ... with 138 more rows

Nombre distinct d'observations

La fonction n() renvoie le nombre de lignes dans le groupe actuel. La fonction associée n_distinct() compte quant à elle les valeurs uniques.

Dans l'exemple suivant, vous additionnez le total des joueurs qu'une équipe a recrutés pendant toutes les périodes.

# distinct values
data %>%
	group_by(teamID) %>%
	summarise(number_player = n_distinct(playerID)) %>%
	arrange(desc(number_player))

Code Explication

• group_by(teamID) : Grouper par équipe
• résumer (number_player = n_distinct(playerID) : Compte les joueurs distincts par équipe
• arrange(desc(number_player)) : Trier les données par nombre de joueurs

Sortie :

## # A tibble: 148 x 2
##    teamID number_player
##    <fctr>         <int>
##  1    CHN           751
##  2    SLN           729
##  3    PHI           699
##  4    PIT           683
##  5    CIN           679
##  6    BOS           647
##  7    CLE           646
##  8    CHA           636
##  9    DET           623
## 10    NYA           612
## # ... with 138 more rows

Plusieurs groupes

Une statistique récapitulative peut être réalisée parmi plusieurs groupes.

# Multiple groups
data %>%
	group_by(yearID, teamID) %>%
	summarise(mean_games = mean(G)) %>%
	arrange(desc(teamID, yearID))

Code Explication

• group_by(yearID, teamID) : groupe par année et équipe
• summarise(mean_games = mean(G)): Calcule la moyenne du nombre de parties jouées
• arrange(desc(teamID, yearID)) : Trier les données par équipe et par année

Sortie :

## # A tibble: 2,829 x 3
## # Groups:   yearID [146]
##    yearID teamID mean_games
##     <int> <fctr>      <dbl>
##  1   1884    WSU   20.41667
##  2   1891    WS9   46.33333
##  3   1886    WS8   22.00000
##  4   1887    WS8   51.00000
##  5   1888    WS8   27.00000
##  6   1889    WS8   52.42857
##  7   1884    WS7    8.00000
##  8   1875    WS6   14.80000
##  9   1873    WS5   16.62500
## 10   1872    WS4    4.20000
## # ... with 2,819 more rows

Filtre

Avant d'avoir l'intention d'effectuer une opération, vous pouvez filtrer l'ensemble de données. L'ensemble de données commence en 1871 et l'analyse n'a pas besoin des années antérieures à 1980.

# Filter
data %>%
	filter(yearID > 1980) %>%
	group_by(yearID) %>%
	summarise(mean_game_year = mean(G))

Code Explication

• filter(yearID > 1980) : filtrez les données pour afficher uniquement les années pertinentes (c'est-à-dire après 1980)
• group_by(yearID) : groupe par année
• summarise(mean_game_year = moyenne(G)) : résumer les données

Sortie :

## # A tibble: 36 x 2
##    yearID mean_game_year
##     <int>          <dbl>
##  1   1981       40.64583
##  2   1982       56.97790
##  3   1983       60.25128
##  4   1984       62.97436
##  5   1985       57.82828
##  6   1986       58.55340
##  7   1987       48.74752
##  8   1988       52.57282
##  9   1989       58.16425
## 10   1990       52.91556
## # ... with 26 more rows

Dissocier

Enfin, vous devez retirer le solping avant de modifier le niveau auquel un calcul est exécuté. Sans la fonction `ungroup()`, la seconde fonction `summarise()` s'exécuterait toujours par joueur.

# Ungroup the data
data %>%
	filter(HR > 0) %>%
	group_by(playerID) %>%
	summarise(average_HR_game = sum(HR) / sum(G)) %>%
	ungroup() %>%
	summarise(total_average_homerun = mean(average_HR_game))

Code Explication

• filter(HR >0) : Exclure zéro homerun
• group_by(playerID) : regrouper par joueur
• summarise(average_HR_game = sum(HR)/sum(G)) : Calculer le circuit moyen par joueur
• ungroup() : supprime le groupeping
• summarise(total_average_homerun = Mean(average_HR_game)) : résumer les données

Sortie :

## # A tibble: 1 x 1
##   total_average_homerun
##                   <dbl>
## 1            0.06882226	

Comment résumer plusieurs colonnes avec across()

Chaque exemple ci-dessus nomme une colonne à la fois. Lorsqu'une même statistique est nécessaire pour plusieurs colonnes, la fonction `across()` l'applique à toutes en un seul appel.

# One function, several columns
data %>%
    group_by(lgID) %>%
    summarise(across(c(R, HR, G), mean, .names = "mean_{.col}"))

# Every numeric column at once
data %>%
    group_by(lgID) %>%
    summarise(across(where(is.numeric), mean, na.rm = TRUE))

# Several functions applied to several columns
data %>%
    group_by(teamID) %>%
    summarise(across(c(R, HR), list(avg = mean, total = sum)))

Trois arguments régissent ce comportement :

• .colonnes: les colonnes sur lesquelles agir, écrites avec les mêmes fonctions d'assistance que select(), y compris where(is.numeric).
• .fns: une fonction, ou une liste nommée de fonctions à appliquer à chaque colonne.
• .noms: le modèle de nommage de la sortie, où {.col} est la colonne et {.fn} le nom de la fonction.

La fonction `across()` a remplacé les anciennes fonctions d'assistance `summarise_all()`, `summarise_at()` et `summarise_if()` dans dplyr 1.0.0. Ces dernières fonctionnent toujours, mais sont obsolètes ; le nouveau code doit donc utiliser `across()`.

Erreurs courantes de la fonction summarise() et comment les corriger

Quatre problèmes expliquent la plupart des échecs d'agrégation.

• Le résultat est NA. Les fonctions mean() et sum() renvoient NA si une valeur est manquante. Ajoutez na.rm = TRUE, comme dans l'exemple mean_SH ci-dessus.
• Le message « summary() a généré une sortie groupée ». Grouping L'utilisation de deux variables permet de regrouper le résultat selon la première variable. Utilisez `.groups = "drop"` pour supprimer le groupe.ping, ou appelez ensuite ungroup().
• Un calcul ultérieur donne un niveau erroné. Un dataframe reste groupé jusqu'à ce qu'il soit dégroupé ; par conséquent, une seconde fonction `summarise()` est exécutée pour chaque groupe. C'est précisément ce que démontre l'exemple de `ungroup()`.
• Le résultat comporte plus de lignes que prévu. La fonction summarise() renvoie une ligne par groupe, ce qui peut entraîner la présence d'un groupe non intentionnel.ping La variable multiplie la sortie. Consultez la ligne « Groupes » affichée au-dessus de chaque tibble.

# Drop the grouping as part of the call
data %>%
    group_by(yearID, teamID) %>%
    summarise(mean_games = mean(G), .groups = "drop")

summarise() en R : Référence de la fonction

Pour obtenir un résumé par groupe, commencez par diviser les données :

# group by X1, X2, X3
group_by(df, X1, X2, X3)

et enlever le solping lorsque le calcul change de niveau :

ungroup(df)

Le tableau ci-dessous répertorie toutes les fonctions utilisées avec summarise() dans ce tutoriel :

summarise(df, mean_x1 = mean(x1))

summarise(df, median_x1 = median(x1))

summarise(df, sum_x1 = sum(x1))

summarise(df, sd_x1 = sd(x1))

summarise(df, interquartile_x1 = IQR(x1))

summarise(df, minimum_x1 = min(x1))

summarise(df, maximum_x1 = max(x1))

summarise(df, quantile_x1 = quantile(x1, probs = 0.75))

summarise(df, first_x1 = first(x1))

summarise(df, last_x1 = last(x1))

summarise(df, nth_x1 = nth(x1, 2))

summarise(df, n_x1 = n())

summarise(df, n_distinct_x1 = n_distinct(x1))

FAQ