Tracés côte à côte avec ggplot2

Je voudrais placer deux tracés côte à côte en utilisant le paquet ggplot2 , c'est-à-dire faire l'équivalent de par(mfrow=c(1,2)).

Par exemple, j'aimerais que les deux tracés suivants s'affichent côte à côte avec la même échelle.

x <- rnorm(100)
eps <- rnorm(100,0,.2)
qplot(x,3*x+eps)
qplot(x,2*x+eps)

Dois-je les mettre dans le même data.frame?

qplot(displ, hwy, data=mpg, facets = . ~ year) + geom_smooth()

Tous les ggplots côte à côte (ou n tracés sur une grille)

La fonction grid.arrange()dans le gridExtrapackage combinera plusieurs tracés; c'est ainsi que vous en mettez deux côte à côte.

require(gridExtra)
plot1 <- qplot(1)
plot2 <- qplot(1)
grid.arrange(plot1, plot2, ncol=2)

Cela est utile lorsque les deux tracés ne sont pas basés sur les mêmes données, par exemple si vous souhaitez tracer des variables différentes sans utiliser reshape ().

Cela tracera la sortie comme un effet secondaire. Pour imprimer l'effet secondaire à un fichier, spécifiez un pilote de périphérique ( par exemple pdf, png, etc.), par exemple

pdf("foo.pdf")
grid.arrange(plot1, plot2)
dev.off()

ou, utiliser arrangeGrob()en combinaison avec ggsave(),

ggsave("foo.pdf", arrangeGrob(plot1, plot2))

C'est l'équivalent de faire deux parcelles distinctes en utilisant par(mfrow = c(1,2)). Cela permet non seulement de gagner du temps lors de l'organisation des données, mais également lorsque vous souhaitez créer deux tracés différents.

Annexe: Utilisation des facettes

Les facettes sont utiles pour créer des tracés similaires pour différents groupes. Ceci est souligné ci-dessous dans de nombreuses réponses ci-dessous, mais je veux souligner cette approche avec des exemples équivalents aux graphiques ci-dessus.

mydata <- data.frame(myGroup = c('a', 'b'), myX = c(1,1))

qplot(data = mydata, 
    x = myX, 
    facets = ~myGroup)

ggplot(data = mydata) + 
    geom_bar(aes(myX)) + 
    facet_wrap(~myGroup)

Mettre à jour

la plot_gridfonction dans le cowplotvaut la peine d'être vérifiée comme alternative à grid.arrange. Voir la réponse de @ claus-wilke ci-dessous et cette vignette pour une approche équivalente; mais la fonction permet des contrôles plus fins sur l'emplacement et la taille du tracé, en fonction de cette vignette .

Un inconvénient des solutions basées sur le grid.arrangefait qu'elles rendent difficile l'étiquetage des parcelles avec des lettres (A, B, etc.), comme la plupart des revues l'exigent.

J'ai écrit le package cowplot pour résoudre ce problème (et quelques autres), en particulier la fonction plot_grid():

library(cowplot)

iris1 <- ggplot(iris, aes(x = Species, y = Sepal.Length)) +
  geom_boxplot() + theme_bw()

iris2 <- ggplot(iris, aes(x = Sepal.Length, fill = Species)) +
  geom_density(alpha = 0.7) + theme_bw() +
  theme(legend.position = c(0.8, 0.8))

plot_grid(iris1, iris2, labels = "AUTO")

L'objet qui plot_grid()retourne est un autre objet ggplot2, et vous pouvez l'enregistrer avec ggsave()comme d'habitude:

p <- plot_grid(iris1, iris2, labels = "AUTO")
ggsave("plot.pdf", p)

Alternativement, vous pouvez utiliser la fonction cowplot save_plot(), qui est une fine enveloppe autour ggsave()qui permet d'obtenir facilement les bonnes dimensions pour les parcelles combinées, par exemple:

p <- plot_grid(iris1, iris2, labels = "AUTO")
save_plot("plot.pdf", p, ncol = 2)

(L' ncol = 2argument indique save_plot()qu'il y a deux tracés côte à côte et save_plot()rend l'image enregistrée deux fois plus large.)

Pour une description plus approfondie de la façon d'organiser les tracés dans une grille, consultez cette vignette. Il existe également une vignette expliquant comment créer des tracés avec une légende partagée.

Un point de confusion fréquent est que le package cowplot change le thème ggplot2 par défaut. Le package se comporte de cette façon car il a été initialement écrit pour des utilisations en laboratoire interne, et nous n'utilisons jamais le thème par défaut. Si cela pose problème, vous pouvez utiliser l'une des trois approches suivantes pour les contourner:

1. Définissez le thème manuellement pour chaque intrigue. Je pense que c'est une bonne pratique de toujours spécifier un thème particulier pour chaque intrigue, comme je l'ai fait avec + theme_bw()dans l'exemple ci-dessus. Si vous spécifiez un thème particulier, le thème par défaut n'a pas d'importance.

2. Rétablissez le thème par défaut à la valeur par défaut ggplot2. Vous pouvez le faire avec une seule ligne de code:

theme_set(theme_gray())

3. Appelez les fonctions cowplot sans attacher le paquet. Vous ne pouvez pas non plus appeler library(cowplot)ou require(cowplot)et appeler à la place des fonctions cowplot en ajoutant le préfixe cowplot::. Par exemple, l'exemple ci-dessus utilisant le thème par défaut ggplot2 deviendrait:

## Commented out, we don't call this
# library(cowplot)

iris1 <- ggplot(iris, aes(x = Species, y = Sepal.Length)) +
  geom_boxplot()

iris2 <- ggplot(iris, aes(x = Sepal.Length, fill = Species)) +
  geom_density(alpha = 0.7) +
  theme(legend.position = c(0.8, 0.8))

cowplot::plot_grid(iris1, iris2, labels = "AUTO")

Mises à jour:

• Depuis cowplot 1.0, le thème ggplot2 par défaut n'est plus modifié.
• Depuis ggplot2 3.0.0, les tracés peuvent être étiquetés directement, voir par exemple ici.

Vous pouvez utiliser la multiplotfonction suivante du livre de recettes R de Winston Chang

multiplot(plot1, plot2, cols=2)

multiplot <- function(..., plotlist=NULL, cols) {
    require(grid)

    # Make a list from the ... arguments and plotlist
    plots <- c(list(...), plotlist)

    numPlots = length(plots)

    # Make the panel
    plotCols = cols                          # Number of columns of plots
    plotRows = ceiling(numPlots/plotCols) # Number of rows needed, calculated from # of cols

    # Set up the page
    grid.newpage()
    pushViewport(viewport(layout = grid.layout(plotRows, plotCols)))
    vplayout <- function(x, y)
        viewport(layout.pos.row = x, layout.pos.col = y)

    # Make each plot, in the correct location
    for (i in 1:numPlots) {
        curRow = ceiling(i/plotCols)
        curCol = (i-1) %% plotCols + 1
        print(plots[[i]], vp = vplayout(curRow, curCol ))
    }

}

En utilisant le package de patchwork , vous pouvez simplement utiliser l' +opérateur:

library(ggplot2)
library(patchwork)

p1 <- ggplot(mtcars) + geom_point(aes(mpg, disp))
p2 <- ggplot(mtcars) + geom_boxplot(aes(gear, disp, group = gear))


p1 + p2

Oui, je pense que vous devez organiser vos données de manière appropriée. Une façon serait la suivante:

X <- data.frame(x=rep(x,2),
                y=c(3*x+eps, 2*x+eps),
                case=rep(c("first","second"), each=100))

qplot(x, y, data=X, facets = . ~ case) + geom_smooth()

Je suis sûr qu'il existe de meilleures astuces dans plyr ou remodeler - je ne suis toujours pas vraiment au courant de tous ces puissants packages de Hadley.

En utilisant le package de remodelage, vous pouvez faire quelque chose comme ça.

library(ggplot2)
wide <- data.frame(x = rnorm(100), eps = rnorm(100, 0, .2))
wide$first <- with(wide, 3 * x + eps)
wide$second <- with(wide, 2 * x + eps)
long <- melt(wide, id.vars = c("x", "eps"))
ggplot(long, aes(x = x, y = value)) + geom_smooth() + geom_point() + facet_grid(.~ variable)

Il existe également un package multipanelfigure qui mérite d'être mentionné. Voir aussi cette réponse .

library(ggplot2)
theme_set(theme_bw())

q1 <- ggplot(mtcars) + geom_point(aes(mpg, disp))
q2 <- ggplot(mtcars) + geom_boxplot(aes(gear, disp, group = gear))
q3 <- ggplot(mtcars) + geom_smooth(aes(disp, qsec))
q4 <- ggplot(mtcars) + geom_bar(aes(carb))

library(magrittr)
library(multipanelfigure)
figure1 <- multi_panel_figure(columns = 2, rows = 2, panel_label_type = "none")
# show the layout
figure1

figure1 %<>%
  fill_panel(q1, column = 1, row = 1) %<>%
  fill_panel(q2, column = 2, row = 1) %<>%
  fill_panel(q3, column = 1, row = 2) %<>%
  fill_panel(q4, column = 2, row = 2)
figure1

# complex layout
figure2 <- multi_panel_figure(columns = 3, rows = 3, panel_label_type = "upper-roman")
figure2

figure2 %<>%
  fill_panel(q1, column = 1:2, row = 1) %<>%
  fill_panel(q2, column = 3, row = 1) %<>%
  fill_panel(q3, column = 1, row = 2) %<>%
  fill_panel(q4, column = 2:3, row = 2:3)
figure2

Créé le 2018-07-06 par le package reprex (v0.2.0.9000).

ggplot2 est basé sur des graphiques en grille, qui fournissent un système différent pour organiser les tracés sur une page. La par(mfrow...)commande n'a pas d'équivalent direct, car les objets de grille (appelés grobs ) ne sont pas nécessairement dessinés immédiatement, mais peuvent être stockés et manipulés en tant qu'objets R normaux avant d'être convertis en sortie graphique. Cela permet une plus grande flexibilité que le dessin de ce modèle de graphiques de base, mais la stratégie est nécessairement un peu différente.

J'ai écrit grid.arrange()pour fournir une interface simple au plus près par(mfrow). Dans sa forme la plus simple, le code ressemblerait à:

library(ggplot2)
x <- rnorm(100)
eps <- rnorm(100,0,.2)
p1 <- qplot(x,3*x+eps)
p2 <- qplot(x,2*x+eps)

library(gridExtra)
grid.arrange(p1, p2, ncol = 2)

Plus d'options sont détaillées dans cette vignette .

Une plainte courante est que les tracés ne sont pas nécessairement alignés, par exemple lorsqu'ils ont des étiquettes d'axe de taille différente, mais cela est de par leur conception: grid.arrangen'essaie pas de cas spécial ggplot2 objets, et les traite également à d'autres grobs (tracés en treillis, par exemple ). Il place simplement les grobs dans une disposition rectangulaire.

Pour le cas spécial des objets ggplot2, j'ai écrit une autre fonction, ggarrangeavec une interface similaire, qui tente d'aligner les panneaux de tracé (y compris les tracés à facettes) et essaie de respecter les rapports d'aspect lorsqu'ils sont définis par l'utilisateur.

library(egg)
ggarrange(p1, p2, ncol = 2)

Les deux fonctions sont compatibles avec ggsave(). Pour un aperçu général des différentes options et du contexte historique, cette vignette offre des informations supplémentaires .

Mise à jour: cette réponse est très ancienne. gridExtra::grid.arrange()est maintenant l'approche recommandée. Je laisse cela ici au cas où cela pourrait être utile.

Stephen Turner a publié la arrange()fonction sur le blog Getting Genetics Done (voir le post pour les instructions d'application)

vp.layout <- function(x, y) viewport(layout.pos.row=x, layout.pos.col=y)
arrange <- function(..., nrow=NULL, ncol=NULL, as.table=FALSE) {
 dots <- list(...)
 n <- length(dots)
 if(is.null(nrow) & is.null(ncol)) { nrow = floor(n/2) ; ncol = ceiling(n/nrow)}
 if(is.null(nrow)) { nrow = ceiling(n/ncol)}
 if(is.null(ncol)) { ncol = ceiling(n/nrow)}
        ## NOTE see n2mfrow in grDevices for possible alternative
grid.newpage()
pushViewport(viewport(layout=grid.layout(nrow,ncol) ) )
 ii.p <- 1
 for(ii.row in seq(1, nrow)){
 ii.table.row <- ii.row 
 if(as.table) {ii.table.row <- nrow - ii.table.row + 1}
  for(ii.col in seq(1, ncol)){
   ii.table <- ii.p
   if(ii.p > n) break
   print(dots[[ii.table]], vp=vp.layout(ii.table.row, ii.col))
   ii.p <- ii.p + 1
  }
 }
}

En utilisant tidyverse:

x <- rnorm(100)
eps <- rnorm(100,0,.2)
df <- data.frame(x, eps) %>% 
  mutate(p1 = 3*x+eps, p2 = 2*x+eps) %>% 
  tidyr::gather("plot", "value", 3:4) %>% 
  ggplot(aes(x = x , y = value)) + 
    geom_point() + 
    geom_smooth() + 
    facet_wrap(~plot, ncol =2)

df

Les solutions ci-dessus peuvent ne pas être efficaces si vous souhaitez tracer plusieurs tracés ggplot à l'aide d'une boucle (par exemple, comme demandé ici: Créer plusieurs tracés dans ggplot avec différentes valeurs de l'axe Y à l'aide d'une boucle ), ce qui est une étape souhaitée dans l'analyse de l'inconnu ( ou grands) ensembles de données (par exemple, lorsque vous voulez tracer le nombre de toutes les variables dans un ensemble de données).

Le code ci-dessous montre comment faire cela en utilisant le 'multiplot ()' mentionné ci-dessus, dont la source est ici: http://www.cookbook-r.com/Graphs/Multiple_graphs_on_one_page_(ggplot2) :

plotAllCounts <- function (dt){   
  plots <- list();
  for(i in 1:ncol(dt)) {
    strX = names(dt)[i]
    print(sprintf("%i: strX = %s", i, strX))
    plots[[i]] <- ggplot(dt) + xlab(strX) +
      geom_point(aes_string(strX),stat="count")
  }

  columnsToPlot <- floor(sqrt(ncol(dt)))
  multiplot(plotlist = plots, cols = columnsToPlot)
}

Maintenant, exécutez la fonction - pour obtenir les comptes pour toutes les variables imprimées à l'aide de ggplot sur une seule page

dt = ggplot2::diamonds
plotAllCounts(dt)

Une chose à noter est que: l'
utilisation aes(get(strX)), que vous utiliseriez normalement dans les boucles lorsque vous travaillez avec ggplot, dans le code ci-dessus au lieu de aes_string(strX)ne dessinera PAS les tracés souhaités. Au lieu de cela, il tracera le dernier tracé plusieurs fois. Je n'ai pas compris pourquoi - il se peut qu'il doive le faire aeset qu'il aes_stringsoit appelé ggplot.

Sinon, j'espère que vous trouverez la fonction utile.

D'après mon expérience, gridExtra: grid.arrange fonctionne parfaitement si vous essayez de générer des tracés en boucle.

Extrait de code court:

gridExtra::grid.arrange(plot1, plot2, ncol = 2)

Le cowplotpackage vous offre un moyen agréable de le faire, d'une manière qui convient à la publication.

x <- rnorm(100)
eps <- rnorm(100,0,.2)
A = qplot(x,3*x+eps, geom = c("point", "smooth"))+theme_gray()
B = qplot(x,2*x+eps, geom = c("point", "smooth"))+theme_gray()
cowplot::plot_grid(A, B, labels = c("A", "B"), align = "v")