CSBQ Atelier R 3

L'écosystème Hadley

ggplot2

Solution # 1

Défi # 1

Intro - ggplot2

Plan de match - ggplot2

Diagramme de dispersion

Intro - ggplot2

Grammaire des

graphiques (gg)

Intro - ggplot2

Diagramme de dispersion ... suite

Diagramme de dispersion (données catégoriques)

Diagramme de dispersion ... suite

Pour mieux suivre l'atelier...

Pourquoi utiliser R pour produire vos graphiques?

Fonction de traçage: "qplot" (quick plot)

Paquets requis

Solution avec jeu de données CO2:

Flexibilité, élégance et sex-appeal!

> qplot(data = iris,

x = Sepal.Length,

y = Sepal.Width)

> ?qplot

Charger et explorer le jeu de

données "iris":

> qplot(data = iris,

x = Species,

y = Sepal.Width)

> ?qplot

> qplot(data = CO2,

x = conc,

xlab = "Concentration de CO2 (mL/L)",

y = uptake,

ylab = "Absorption de CO2 (umol/m^2 sec)",

main = "Absorption de CO2 chez une espèce de graminée")

> install.packages(ggplot2)

> library(ggplot2)

Flux de travail divisé

> qplot(data = iris,

x = Sepal.Length,

xlab = "Longueur (mm)",

y=Sepal.Width,

ylab = "Largeur (mm)",

main = "Dimensions de sépales")

Produire un diagramme de dispersion de base à l'aide d'un nouveau jeu de données:

Reproductibilité de votre

flux de travail

Un graphique est composé d'éléments distincts (couches) superposés:

• données:
• esthétique (aesthetic --> aes)
• transformation
• geoms (objets géométriques)
• axes (système de coordonnées)
• échelles

• Avez-vous déjà créé des graphiques?
• Quel type?
• Avec quel logiciel?
• Avec R?
• base R, lattice?
• ggplot2?

1. Votre premier graphique R:

• Diagramme de dispersion de base
• Défi # 1

2. Grammaire des graphiques (grammar of graphics)

• Graphiques plus avancés
• Variété des éléments de graphique et savoir quand/comment les utiliser
• Défi # 2

3. Sauvegarder vos graphiques

4. Détails esthétiques

• couleurs
• themes

5. Divers trucs cool

arguments:

• data
• x
• y
• ...

Code et explications disponibles ici:

http://qcbs.ca/wiki/r_atelier3

Recommandations:

• créez vos propres scripts
• utilisez le code fourni seulement lorsque requis
• évitez de copier coller le code du script fourni

ggplot2 est hébergé sur github:

https://github.com/hadley/ggplot2

> data(iris)

> ?iris

> head(iris)

> str(iris)

> names(iris)

arguments:

• data
• x
• y
• ...

> ?CO2

> data(CO2)

> ?BOD

> data(BOD)

Toé !

• xlab
• ylab
• main

Couleurs et symboles

Ressources additionnelles

Groups

Group

Facet

"facet" et "group"

Variétés d'éléments

qplot() vs ggplot()

Comment ça marche?

Régressions linéaires

Solution # 2

Grammaire des

graphiques (gg)

Défi # 2

Diagramme de dispersion dans un objet R

Syntaxe de base:

http://docs.ggplot2.org

> help(package = ggplot2)

Spécifier les groupes à distinguer:

Ajouter un "geom" de ligne:

> objet.graph <- objet.graph + facet_grid(rows~columns)

> CO2.graph <- ggplot(data = CO2, aes(x = conc, y = uptake, colour = Treatment)) +

geom_point() +

xlab("Concentration en CO2 (mL/L)") +

ylab("Absorption de CO2 (umol/m^2 sec)") +

ggtitle("Absorption de CO2 par une espèce de graminée")

> CO2.graph

> qplot(data = iris,

x = Sepal.Length,

xlab = "Longueur (mm)",

y = Sepal.Width,

ylab = "Largeur (mm)",

main = "Dimensions de sépales d'iris")

> graph.base <- graph.base + aes(colour = Species, shape = Species)

> graph.base

> objet.graph <- ggplot() OU qplot()

> CO2.graph + geom_line()

Ajouter aes():

> CO2.graph <- CO2.graph + geom_line(aes(group=Plant))

> CO2.graph

Ajouter un geom (e.g. linear smoothing):

> graph.ligne <- graph.base +

geom_smooth(method="lm", se = FALSE)

> graph.ligne

1. Créer un graphique simple, assigné à un objet R

E.g. Graphique CO2 par "Type":

> CO2.graph <- ggplot(data = CO2, aes(x = conc, y = uptake, colour = Treatment)) +

geom_point() +

xlab("Concentration en CO2 (mL/L)") +

ylab("Absorption de CO2 (umol/m^2 sec)") +

ggtitle("Absorption de CO2 par une espèce de graminée") +

geom_smooth(method = "loess")

> CO2.graph

Produire un diagramme de dispersion avec des couleurs et des régressions linéaires (ou autre "smoothing") en utilisant un autre jeu de données:

graph.base <- ggplot(data = iris, aes(x = Sepal.Length, y = Sepal.Width)) +

geom_point() +

xlab("Longueur (mm)") +

ylab("Largeur (mm)") +

ggtitle("Dimensions de sépales d'iris")

graph.base

• Avantage: une petite modification d'un seul élément distinct produit un nouveau graphique

e.g. changer le système de coordonnées

> CO2.graph <- CO2.graph + facet_grid(.~Type)

> CO2.graph

> ggplot(data = iris, aes(x = Sepal.Length, y = Sepal.Width)) +

geom_point() +

xlab("Longueur (mm)") +

ylab("Largeur (mm)") +

ggtitle("Dimensions de sépales d'iris")

> objet.graph <- objet.graph + couche()

2. Ajouter des éléments graphiques et esthétiques

Objets géométriques (geoms)

• point: diagramme de dispersion
• line: graphique de lignes, données liées en ordre croissant des valeurs de x
• path: graphique de lignes trajectoires, données liées par leur séquence originale dans le jeu de données
• boxplot: lorsque y est catégorique
• bar: diagramme à bandes (données catégoriques)
• histogram: histogrammes (données numériques 1D)

"Aesthetics" (aes) rend les données visibles:

• x,y : coordonnées cartésiennes
• colour: la couleur des points, lignes, etc...
• group: le groupe du point de données
• shape: le symbole pour représenter le point
• linetype: type de ligne (pleine, pointillée, etc...)
• size: taille des points ou des lignes
• alpha: transparence des points ou des lignes

> ?CO2

> data(CO2)

> ?msleep

> data(msleep)

> objet.graph

3. Répéter l'étape 2 jusqu'à satisfaction et imprimer votre chef-d'oeuvre!

Credits: Software and Programer Efficiency Group

BONUS!

Sauvegarder dans RStudio

Détails esthétiques: couleurs

Détails esthétiques: axes

Détails esthétiques: thèmes

BONUS!

Défi # 3

Détails esthétiques: ggthemes

Solution # 3

Détails esthétiques: RColorBrewer

Détails esthétiques:

à la Wes Anderson

Sauvegarder vos graphiques avec ggsave

BONUS !

Graphique de base R

• Écologiste? Utilisateur de vegan?

Êtes-vous fan de Wes Anderson?

ggvegan! ...en développement sur Github!

• GUI de ggplot2 en ligne: http://rweb.stat.ucla.edu/ggplot2/

> ?plot

> CO2.graph + scale_y_continuous(name = "Taux d'absorption de CO2",

breaks = seq(5,50, by = 10),

labels = seq(5,50, by = 10),

trans = "log10")

> objet.graph + theme()

Dans un script:

> CO2.graph +

scale_colour_manual(values = c("nonchilled" = "red","chilled" = "blue"))

> install.packages("RColorBrewer")

> library(RColorBrewer)

> graph.base + scale_color_brewer(palette = "Dark2")

https://github.com/karthik/wesanderson

https://github.com/jrnold/ggthemes

Comment:

> box.graph <- ggplot(data = OrchardSprays,

aes(x = treatment, y = decrease)) +

geom_boxplot()

> box.graph

> install.packages(ggthemes)

> library(ggthemes)

> tufte.box <- ggplot(data = OrchardSprays, aes(x = treatment, y = decrease)) +

geom_tufteboxplot() +

theme_tufte()

tufte.box

Explorer un nouveau type de "geom" et autres éléments graphiques avec votre propre jeu de données ou un des jeux suivants:

• Semblable à la syntaxe de qplot()
• Graphique par défaut associé à des types d'objets R, très puissant!

> devtools::install_github("wesanderson", "karthik")

> library(wesanderson)

> graph.base +

scale_color_manual(values = wes_palette("GrandBudapest", 3))

> ggsave("CO2graph.pdf",

CO2.graph,

height = 8.5,

width = 11,

units = "in")

Centre de la science de la biodiversité du Québec

Série d'ateliers R

theme_grey(), theme_bw(), etc...

> plot (iris)

Thèmes de base:

N.B. Les formats vecteurs (pdf, svg, etc...) sont souvent plus avantageux que les formats rasters (jpeg, png, etc...).

Thèmes:

• Tufte
• The Economist
• Five Thirty Eight

> ?msleep

> data(msleep)

> ?OrchardSprays

> data(OrchardSprays)

> lm <- lm(Sepal.Length ~

Petal.Width,

data = iris)

> plot(lm)

Autres méthodes:

Créer vos propres thèmes:

> mytheme <- theme_grey() +

theme(plot.title = element_text(colour = "red")) +

theme(legend.position = c(0.9, 0.9))

> objet.graph + mytheme

> ?pdf

> ?jpeg

NB: vous pouvez aussi produire des biplots dans ggplot2 de base: il suffit d'extraire la position des objets et de créer votre diagramme de double projection un élément à la fois.

tidyr

tidyr - Faire le ménage

tidyr - Installation

Gather() - exemple

Intro

données en longueur vs. en largeur

Gather() - exemple

Intro

Le format de nos données

Spread()

éparpiller des colonnes

Gather()

ramasser des colonnes

Exemple

dimensions d'arbres

Défi # 4

Solution # 4

FORMAT EN LARGEUR

Transformez le jeu de données "degat.long" en format large:

Transformez le jeu de données "degat" en format long:

Installez et chargez le paquet:

C

Variable 1

Variable 2

Variable 3

ID variable (e.g. site)

> degat.large <- spread(degat.long, dimension, cm)

B

Format long

A

> degat.long <- gather(degat, dimension, cm, c(DHP, Haut))

Format large

A

Format long

B

Supposons que vous envoyez votre assistant de terrain pour faire la collecte de données des dimensions de plusieurs arbres sur un site de recherche, sois le diamètre à la hauteur de la poitrine (DHP) et la hauteur. Il vous revient avec ceci:

Format large

> air.long <- gather(airquality, variable, value, -Month, -Day)

> head(air.long)

ID 1 Measured value Measured value Measured value

> install.packages("tidyr")

> library(tidyr)

ID 2 Measured value Measured value Measured value

Éparpillez le jeu de données "airquality" en format long. Ensuite, ramassez-le en format large pour retrouver le format original de "airquality".

ID 3 Measured value Measured value Measured value

Format large

Format long

# Notez que la syntaxe ici indique qu'on veut "ramasser" toutes les colonnes sauf "Month" et "Day", c'est donc l'équivalent de dire "c(Ozone, Solar.R, Temp, Wind)"

> degat <- data.frame( Species = c("Chêne", "Orme", "Frêne"),

DHP = c(12, 20, 13),

Haut = c(56, 85, 55))

Format long

Format large

Le paquet tidyr nous permet de modifier la structure des données tout en préservant l'information contenue dans le jeu de données

1. “ramasser” les données (gather)

large –> long

2. “éparpiller” les données (spread)

long –> large

Format en longueur: une colonne indiquant les variables possibles et une colonne avec les données associées aux variables.

Format en largeur: une colonne par variable ou facteur dans votre étude.

Le format en largeur peut-être utilisé pour des graphiques de base dans ggplot2, mais les diagrammes plus complexes requièrent le format en longueur. Exemples à venir!

plyr, lm(), glm() et gam() requièrent le format en longueur.

ID variable (e.g. site)

Factor

Measured value

> air.wide <- spread(air.long , variable, value)

> head(air.wide)

> ?airquality

> data(airquality)

Arguments de la fonction:

• le jeu de données
• le nom de la nouvelle colonne spécifiant la variable mesurée (A)
• le nom de la nouvelle colonne spécifiant la mesure associée (B)
• les colonnes qu'on veut empiler dans le jeu de données (C)

Arguments de la fonction:

• le jeu de données
• le nom de la colonne contenant le nom des variables, donc le titre des nouvelles colonnes (A)
• le nom de la colonne contenant les valeurs associées aux variables (B)

Format large

ID 1 Variable 1 #

ID 1 Variable 2 #

ID 1 Variable 3 #

ID 2 Variable 1 #

ID 2 Variable 2 #

ID 2 Variable 3 #

ID 3 Variable 1 #

ID 3 Variable 2 #

ID 3 Variable 3 #

FORMAT EN LONGUEUR

Seperate() - exemple

Seperate()

séparer des colonnes

Exercices - ggplot et tidyr

Exercises - ggplot et tidyr

Exercices - ggplot et tidyr

Atelier 3:

ggplot2, tidyr et dplyr

Créez un jeu de données fictif sur les poissons et le zooplancton:

Ensuite, si on s'intéresse à la variable du temps (T1 et T2), on peut la séparer dans sa propre colonne:

En premier lieu, on ramasse le "gros.degat" pour le convertir en format long:

Nous pouvons également conserver les données en format en largeur si nous désirons construire des graphiques individuels pour chaque variable pour chaque jour de chacun des 5 mois.

Au lieu, nous pouvons convertir "airquality" en format en longueur afin d'utiliser facet_wrap() pour regrouper les panneaux par variables et non par mois.

head(airquality)

B

C

D

A

Nous pouvons utiliser la fonction grid.arrange() du paquet gridExtra pour créer des graphiques à panneaux multiples comme suit:

> gros.degat.long.sep <- separate(gros.degat.long, taxa, into = c("especes", "temps"), sep = "\\.")

> head(gros.degat.long.sep)

> gros.degat.long <- gather(gros.degat, taxa, count, -id, -trt)

> head(gros.degat.long)

"airquality" est dans un format large, c'est-à-dire que les variables (Ozone, Solar.R, Wind et Temp) occupent leur propre colonne.

air.long <- gather(airquality, variable, value, -Month, -Day)

air.large <- spread(air.long , variable, value)

> set.seed(8)

> gros.degat <- data.frame(id = 1:4,

trt = sample(rep(c('controle', 'culture'), each = 2)),

zooplancton.T1 = runif(4),

poisson.T1 = runif(4),

zooplancton.T2 = runif(4),

poisson.T2 = runif(4))

# Notez qu'on utilise "\\." au lieu de "." parce que dans le langage R, le point est une carte frime

library(gridExtra)

combo.box <- grid.arrange(ozone.box, solar.box, temp.box, wind.box, nrow = 2)

Utilisons ggplot2 pour créer des graphiques pour chaque variable.

Utilisez ensuite le format en longueur pour créer des graphiques dans ggplot2:

> ozone.graph <- ggplot(airquality, aes(x = Day, y = Ozone)) + geom_point() +

geom_smooth() + facet_wrap(~ Month, nrow = 2)

> solar.graph <- ggplot(airquality, aes(x = Day, y = Solar.R)) + geom_point() +

geom_smooth() + facet_wrap(~Month, nrow = 2)

> wind.graph <- ggplot(airquality, aes(x = Day, y = Wind)) + geom_point() +

geom_smooth() + facet_wrap(~Month, nrow = 2)

> temp.graph <- ggplot(airquality, aes(x = Day, y = Temp)) + geom_point() +

geom_smooth() + facet_wrap(~Month, nrow = 2)

> combo.facets <- grid.arrange(ozone.graph, solar.graph, wind.graph, temp.graph, nrow = 4)

fMonth <- factor(airquality$Month) # Convertit la variable "Month" en facteur.

ozone.box <- ggplot(airquality, aes(x = fMonth, y = Ozone)) + geom_boxplot()

solar.box <- ggplot(airquality, aes(x = fMonth, y = Solar.R)) + geom_boxplot()

temp.box <- ggplot(airquality, aes(x = fMonth, y = Temp)) + geom_boxplot()

wind.box <- ggplot(airquality, aes(x = fMonth, y = Wind)) + geom_boxplot()

Arguments de la fonction:

• data : le jeu de données
• col : le nom de la colonne que nous voulons séparer (A)
• into : les noms des nouvelles colonnes (B, C, D)
• by : le critère expliquant où/comment séparer le contenu

Notez, par contre, que contrairement à l'élément facet() dans ggplot2, les échelles des axes ne seront pas les mêmes dans chaque panneau.

fMonth.long <- factor(air.long$Month)

meteo <- ggplot(air.long, aes(x = fMonth.long, y = value)) +

geom_boxplot() +

facet_wrap(~ variable, nrow = 2)

Comparez le graphique "meteo" avec "combo.box".

Ici, nous utilisons une combinaison de grid.arrange() et facet_wrap(), un mélange qui laisse à désirer esthétiquement!

Exercices - ggplot et tidyr

Les variables de l'objet meteo sont sur la même échelle en utilisant la fonction facet_wrap(). Ça peut être utile dans plusieurs circonstances, mais ça ne permet pas de voir toute la variation de la variable “Wind”. On peut "libérer" l'axe des y:

On peut aussi utiliser le format long pour créer un graphique qui inclut toutes les variables sur un seul panneau :

meteo <- meteo + facet_wrap(~variable, nrow = 2, scales = "free")

meteo2 <- ggplot(air.long, aes(x = Day, y = value, colour = variable)) +

geom_point() +

facet_wrap(~Month, nrow = 1)

Site web: http://qcbs.ca/wiki/r_atelier3

dplyr

select() - exemple

filter()

filter() - exemple

select()

arrange()

Manipulation de données

Intro - dplyr

Intro - dplyr

Fonctions dplyr de base

Manipulation de données

Supposons qu'on s'intéresse aux périodes de canicules du mois d'août dans le jeu de données airquality:

Selection d'un sous-ensemble d'observations (rangées) correspondant à un critère:

Selection d'un sous-ensemble de variables (colonnes)

trier le contenu d'une colonne en ordre croissant (par défaut) ou décroissant (avec desc() ), alphabétiquement ou numériquement

Supposons qu'on s'intéresse à la variation de la variable Ozone avec le temps dans ''airquality''

Avez-vous déjà utilisé ces fonctions:

Paquets requis:

La mission dplyr:

Voici 4 verbes qui exécutent les opérations les plus commune :

split()

by()

lapply()

> install.packages("dplyr")

> library(dplyr)

> ?arrange

> aout <- filter(airquality,

Month == 8,

Temp >= 90)

> head(aout)

> ozone <- select(airquality, Ozone,

Month, Day)

> head(ozone)

• distiller tous les tâches de manipulation en un groupe de verbe intuitif et conhérent
• offrir une belle complémentarité avec RStudio
• traiter des gros jeux de données très rapidement (C++)
• établir des connections à des bases de données SQL, et traduire votre code en requête SQL

Qu'avez-vous utilisé dans le passé?

sapply()

do.call()

merge()

> ?select

> ?filter

• select() : sélectionne sous-ensemble de colonnes
• filter() : sélectionne sous-ensemble de rangées
• arrange() : trie les données en ordre
• mutate() : crée des données dans une nouvelle colonne

arguments:

• data
• 1ère colonne à trier
• 2e colonne à trier
• ...

rbind()

subset()

apply()

arguments:

• data
• colonne 1
• colonne 2
• ...

arguments:

• data
• proposition logique 1
• proposition logique 2
• ...

(... et pleuré un peu?)

magrittr

magrittr - exemple

mutate() - exemple

magrittr - exemple

arrange() - exemple

magrittr - exemple

mutate()

dplyr - groupes et aggrégation

magrittr

Supposons qu'on vient juste d'importer un jeu de données un peu chaotique:

Créer des nouvelles variables (colonnes)

Quel code est plus élégant en votre opinion?

Et pour 10 étapes d'opérations?

Dans le jeu de données "airquality", la température est en degré Fahrenheit. Transformons la variable Temp en degré Celsius

Au lieu d'envelopper toutes les fonctions, on peut écrire les opérations en ordre d'exécutions et les relier à l'aide du “pipe” %>% :

On peut utiliser "arrange()" pour réarranger le jeu de données en ordre chronologique, soit en ordre croissant de "Month" et ensuite en ordre croissant de "Day"

Paquet requis

Supposons qu'on veut créer un sous-ensemble de airquality pour le mois de juin, et ensuite convertir la variable de la température en degré Celsius. On peut combiner deux verbes dplyr comme suit:

La vrai nature jedi du paquet dplyr se revèle lorsqu'on combine plusieurs verbes dplyr. dplyr nous permets aussi d'exécuter des opérations sur des sous-ensembles de nos jeux de données et d'agréger l'information:

> air_chron <- arrange(air_mess, Month, Day)

> head(air_chron)

> air_degat <- sample_frac(airquality, 1)

> head(air_degat)

> juin_C <- airquality %>%

filter(Month == 6) %>%

mutate(Temp_C = (Temp-32)*(5/9))

> install.packages(magrittr)

> library(magrittr)

> airquality_C <- mutate(airquality,

Temp_C = (Temp-32)*(5/9))

> head(airquality_C)

> juin_C <- airquality %>%

filter(Month == 6) %>%

mutate(Temp_C = (Temp-32)*(5/9))

> juin_C <- mutate(

filter(airquality, Month == 6),

Temp_C = (Temp-32)*(5/9)

)

OR

Habituellement, la manipulation d'un jeu de données requière plusieurs étapes. Le paquet magrittr nous permet de relier plusieurs verbes dplyr pour créer un pipeline.

> ?mutate

# Notez l'absence du premier argument dans chaque fonction

• group_by() : regrouper le jeu de donner par un facteur pour les opérations en aval (comme summarise)
• summarise() : créer un sommaire de variables au sein de groupes distincts dans un jeu de données en utilisant des fonctions d'aggrégation (e.g. min(), max(), mean(), etc…)

arguments:

• data
• expression 1
• expression 2
• ...

> juin_C <- mutate(

filter(airquality, Month == 6),

Temp_C = (Temp-32)*(5/9)

)

Ici, le "pipe" redirige la sortie (output) d'une fonction en amont vers l'entrée (input) d'une fonction en aval. En utilisant le "pipe", on peut lire et écrire les opérations dans le même ordre qu'elles sont exécutées.

Ceci est difficile à lire parce que l'ordre des opérations exécutées commence au centre et se lit vers l'extérieur jusqu'à la fonction enveloppant le tout

%>%

# inversez l'ordre de "Month" et "Day" dans la fonction pour voir le résultat

dplyr défi # 5

group_by() : Split-Apply-Combine

group_by() et summarise()

Défi 5 Solution

summarise()

L'aventure dplyr se poursuit

Défi 5 Solution

dplyr ninja jedi Solution

dplyr jedi ninja

Défi # 6

Exemple: supposons qu'on s'intéresse à la température moyenne et l'écart type pour chaque mois:

Crée des sommaires à l'aide de fonction d'aggrégation

dplyr offre beaucoup de fonctions puissantes que nous n'avons pas le temps de couvrir aujourd'hui

La fonction group_by() est très importante puisqu'elle nous permet d'exploiter la stratégie "Séparer-Appliquer-Combiner" facilement:

1. D'abord on doit créer des sous-ensembles pour chaque poussin à l'aide group_by()

2. Ensuite, on peut utiliser summarise() pour calculer la différence entre la masse maximum de chaque poussin

1. On utilise group_by() pour créer des sous-ensembles par ''Diet" ET ''Chick" (l'ordre est important)

2. On utlise summarise(), pour calculer la différence de masse entre la fin (last()) et le début (first() ) de l'étude

3. Finalement on utilise un 2e summarise() (par "Diet", le groupe restant) pour calculer la moyenne

En utilisant le jeu de données ChickWeight, créez un tableau sommaire nous indiquant, pour chaque Diet, la moyenne de la différence de masse entre la fin et le début de l'étude pour chaque poussin. Utilisez les verbes dplyr et le pipe %>%.

• fusion de tableaux de données : left_join(), inner_join(), etc...
• interface base de données SQL
• etc...

> mois_moy <- airquality %>%

group_by(Month) %>%

summarise(mean_temp = mean(Temp),

sd_temp = sd(Temp))

> head(mois_moy)

En utilisant le jeu de données "ChickWeight", créez un tableau sommaire dans lequel on retrouve la différence de masse entre le maximum et le minimum de la masse enregistré pour chaque poussin dans l'étude. Utilisez les verbes dplyr et le “pipe” %>%.

> mass_diff <- ChickWeight %>%

group_by(Chick) %>%

summarise(mass_diff = max(weight) - min(weight))

> mass_diff

diet_mass <- ChickWeight %>%

group_by(Diet, Chick) %>%

summarise(gain_masse = last(weight) - first(weight)) %>%

summarise(gain_moyen = mean(gain_masse))

diet_mass

Jetez un coup d'oeil sur le wiki pour des liens vers du matériels intéressants pour en apprendre davantage

INDICE 1 : Les fonctions dplyr first() et last() pourrait s'avérer utile

INDICE 2 : Au sein de "group_by()", on peut regrouper par plusieurs variables pour créer un "oignon", et chaque utilisation distinct de la fonction "summarise()" élimine une couche de l'oignon (en commençant par la couche extérieur, donc la dernière variable dans "group_by()")

# Notez: la différence entre le min et

le max de la masse ne correspond pas

nécéssairement avec le gain de masse entre le temps 0 et la fin de l'étude. Inspectez le poussin # 18!!!!!!!!!