Fonction d'agrégation R : exemple de résumé et de Group_by()

Le résumé d’une variable est important pour avoir une idée des données. Cependant, résumer une variable par groupe donne de meilleures informations sur la distribution des données.

Dans ce tutoriel, vous apprendrez comment résumer un jeu de données par groupe avec la bibliothèque dplyr.

Pour ce didacticiel, vous utiliserez l'ensemble de données au bâton. L'ensemble de données d'origine contient 102816 22 observations et 20 variables. Vous n'utiliserez que  % de cet ensemble de données et utiliserez les variables suivantes :

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

Explication du code

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

Explication du code

• 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 contre pas de group_by

La fonction summerise() sans group_by() n'a aucun sens. Il crée des statistiques récapitulatives par groupe. La bibliothèque déplyr applique automatiquement une fonction au groupe que vous avez passé dans le verbe group_by.

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

Explication du code

• data : ensemble de données utilisé pour construire les statistiques récapitulatives
• group_by(lgID) : Calculez le résumé en regroupant la variable `lgID
• 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	

L'opérateur pipe fonctionne également avec ggplot(). Vous pouvez facilement afficher les statistiques récapitulatives avec un graphique. Toutes les étapes sont poussées à l'intérieur du pipeline jusqu'à ce que le tracé soit tracé. Il semble plus visuel de voir le circuit moyen par ligue avec une barre. Le code ci-dessous démontre la puissance de la combinaison group_by(), summarise() et ggplot().

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 :

Fonction en résumé()

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

Nous verrons des exemples pour chaque fonction du tableau 1.

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 procéder en deux étapes pour générer une trame de date à partir d'un récapitulatif :

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

Explication du code

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

Explication du code

• 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		

Il existe de nombreuses inégalités dans la quantité de circuits réalisés par chaque équipe.

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

Compter les observations par groupe est toujours une bonne idée. Avec R, vous pouvez agréger le nombre d'occurrences avec n().

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() est complémentaire de first() et last(). Vous pouvez accéder à la nième observation au sein d'un groupe avec l'index à retourner.

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 d'observations dans un groupe actuel. Une fonction fermée à n() est n_distinct(), qui compte le nombre de 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))

Explication du code

• group_by(teamID) : groupe par année et équipe
• résumer (number_player = n_distinct(playerID)) : Comptez le nombre distinct de joueurs 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))

Explication du code

• group_by(yearID, teamID) : groupe par année et équipe
• summarise(mean_games = Mean(G)) : Résumer le nombre de joueurs
• 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

Filtrer

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

Explication du code

• 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 et surtout, vous devez supprimer le regroupement avant de vouloir modifier le niveau de calcul.

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

Explication du code

• 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 regroupement
• 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	

Résumé

Lorsque vous souhaitez retourner un récapitulatif par groupe, vous pouvez utiliser :

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

vous devez dissocier les données avec :

ungroup(df)

Le tableau ci-dessous résume la fonction que vous avez apprise avec summarise()

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

summarise(df,first_x1 = first(x1))

summarise(df,last_x1 = last(x1))

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

summarise(df,n_x1 = n(x1))

summarise(df,n_distinct _x1 = n_distinct(x1))