Suppress warning: (‘future_lapply-*’) added, removed, or modified devices for ggExtra::ggMarginal

[elgabbas]

When using ggExtra::ggMarginal() within a parallelized workflow using future.apply::future_lapply() with plan(multisession), multiple warnings are triggered indicating that graphics devices are being opened and not properly closed.

Reproducible Example:

library(ggplot2)
library(ggExtra)
library(tibble)
library(future.apply)

# Set up parallel processing
plan(multisession, workers = 2)

# Function to simulate plotting operation with ggExtra::ggMarginal
plot_function <- function(x) {
  
  # Sample data
  data <- data.frame(x = rnorm(100), y = rnorm(100))
  y_min <- min(data$y)
  y_max <- max(data$y)
  
  # Create the base plot
  Plot <- ggplot(data, aes(x, y)) +
    geom_point(color = "steelblue4") +
    theme_minimal()
  
  # Add marginal histogram using ggExtra::ggMarginal
  Plot_Marginal <- ggExtra::ggMarginal(
    p = Plot, type = "histogram", margins = "y", size = 6,
    color = "steelblue4", fill = "steelblue4", bins = 50
  )
  
  NULL
}

# Apply the function in parallel
results <- future_lapply(1:5, plot_function, future.seed = TRUE)

I received the following warning (Linux HPC). The warning is repeated with the number of cores used

Warning messages:
1: MultisessionFuture (‘future_lapply-1’) added, removed, or modified devices. A future expression must close any opened devices and must not close devices it did not open. Details: 1 devices differ: index=2, before=‘NA’, after=‘pdf’
2: MultisessionFuture (‘future_lapply-2’) added, removed, or modified devices. A future expression must close any opened devices and must not close devices it did not open. Details: 1 devices differ: index=2, before=‘NA’, after=‘pdf’

In the previous example, I only created the plot object without explicitly saving the plot to a file. Running the code resulted in a redundant PDF file saved to the working directory Rplots.pdf.

Interestingly, when I apply the function again and again, I receive no warnings

results <- future_lapply(1:5, plot_function, future.seed = TRUE)
results <- future_lapply(1:5, plot_function, future.seed = TRUE)
results <- future_lapply(1:5, plot_function, future.seed = TRUE)

Is it possible to disable this warning without using suppressWarnings?

Thanks

[HenrikBengtsson]

Warning messages:
1: MultisessionFuture (‘future_lapply-1’) added, removed, or modified devices. A future expression must close any opened devices and must not close devices it did not open. Details: 1 devices differ: index=2, before=‘NA’, after=‘pdf’
2: MultisessionFuture (‘future_lapply-2’) added, removed, or modified devices. A future expression must close any opened devices and must not close devices it did not open. Details: 1 devices differ: index=2, before=‘NA’, after=‘pdf’

Those warnings are by design and there to make us aware of graphical devices being opened and left behind without our knowledge. So, this works exactly as wanted. This check was introduced in future 1.40.0.

Now, the problem is that ggExtra::ggMarginal() opens a graphical device. Here's a minimal example:

library(future)
library(ggplot2)

# Sample data
data <- data.frame(x = rnorm(100), y = rnorm(100))
plot <- ggplot(data, aes(x, y)) + geom_point()

f <- future({
  ggExtra::ggMarginal(p = plot, type = "histogram")
})
v <- value(f)

If you run this with plan(sequential), you'll see the device being opened on your screen or in your GUI. If you run it on a parallel backend, that function falls back to open a PDF device, which is what we see in the warning.

I'm not sure what you want to do with that plot being generated, but if you want to return the plot object and display it locally, you can do something like:

f <- future({
  ## Open a temporary PDF graphics device that writes to void
  pdf(nullfile())
  on.exit(dev.off())
  
  ggExtra::ggMarginal(p = plot, type = "histogram")
})
plot <- value(f)

That will open a temporary PDF graphics device for ggExtra to use and then shut it down on exit. You can then plot the graph locally by:

print(plot)

See also my 2016-10-11 blog post ' Remote Processing Using Futures' (https://www.jottr.org/2016/10/11/future-remotes/), which illustrates the idea of generating graphs remotely, but displaying them locally.

Interestingly, when I apply the function again and again, I receive no warnings

The reason for this is that ggExtra opened a PDF graphics device, which writes to that Rplots.pdf file (default filename), and leaves it open on the parallel worker. So, it'll keep using that in all the following calls. Sounds neat, but that's nothing you want to rely on.

[elgabbas]

Thanks @HenrikBengtsson.

This did not work for me. I would like to prepare many marginal plots in parallel, then I will arrange them using patchwork in different ways. I need to return the ggplot object or a tibble with a list column containing the ggplot object.

Original function:

library(ggplot2)
library(ggExtra)
library(future.apply)
plan(multisession, workers = 2)

plot_function <- function(x) {
  data <- data.frame(x = rnorm(100), y = rnorm(100))
  Plot <- ggplot(data, aes(x, y)) + geom_point(color = "steelblue4")
  Plot_marginal <- ggExtra::ggMarginal(
    p = Plot, type = "histogram", margins = "y", size = 6,
    color = "steelblue4", fill = "steelblue4", bins = 50)
  return(Plot_marginal)
}
results <- future_lapply(1:5, plot_function, future.seed = TRUE)
# Warning messages:
#   1: MultisessionFuture (‘future_lapply-1’) added, removed, or modified devices. A future expression must close any opened devices and must not close devices it did not open. Details: 1 devices differ: index=2, before=‘NA’, after=‘pdf’ 
# 2: MultisessionFuture (‘future_lapply-2’) added, removed, or modified devices. A future expression must close any opened devices and must not close devices it did not open. Details: 1 devices differ: index=2, before=‘NA’, after=‘pdf’ 

Running the same function again gave no warnings!

results <- future_lapply(6:10, plot_function, future.seed = TRUE)
results <- future_lapply(11:15, plot_function, future.seed = TRUE)
results <- future_lapply(16:20, plot_function, future.seed = TRUE)

Using pdf(nullfile()) in a fresh R session did not help

# New R session
library(ggplot2)
library(ggExtra)
library(future.apply)
plan(multisession, workers = 2)

plot_function2 <- function(x) {
  
  pdf(nullfile())
  
  data <- data.frame(x = rnorm(100), y = rnorm(100))
  Plot <- ggplot(data, aes(x, y)) + geom_point(color = "steelblue4")
  Plot_marginal <- ggExtra::ggMarginal(
    p = Plot, type = "histogram", margins = "y", size = 6,
    color = "steelblue4", fill = "steelblue4", bins = 50)
  
  dev.off()
  return(Plot_marginal)
}
results2 <- future_lapply(1:5, plot_function2, future.seed = TRUE)

# Warning messages:
#   1: MultisessionFuture (‘future_lapply-1’) added, removed, or modified devices. A future expression must close any opened devices and must not close devices it did not open. Details: 1 devices differ: index=3, before=‘NA’, after=‘’ 
# 2: MultisessionFuture (‘future_lapply-2’) added, removed, or modified devices. A future expression must close any opened devices and must not close devices it did not open. Details: 1 devices differ: index=3, before=‘NA’, after=‘’ 

Using a valid file path did not help as well.

# New R session
library(ggplot2)
library(ggExtra)
library(future.apply)
plan(multisession, workers = 2)

plot_function3 <- function(x) {
  temp_file <- tempfile(fileext = ".pdf")
  grDevices::pdf(temp_file)
  
  data <- data.frame(x = rnorm(100), y = rnorm(100))
  Plot <- ggplot(data, aes(x, y)) + geom_point(color = "steelblue4")
  Plot_marginal <- ggExtra::ggMarginal(
    p = Plot, type = "histogram", margins = "y", size = 6,
    color = "steelblue4", fill = "steelblue4", bins = 50)
  
  grDevices::dev.off()
  fs::file_delete(temp_file)
  return(Plot_marginal)
}

results3 <- future_lapply(1:5, plot_function3, future.seed = TRUE)

# Warning messages:
#   1: MultisessionFuture (‘future_lapply-1’) added, removed, or modified devices. A future expression must close any opened devices and must not close devices it did not open. Details: 1 devices differ: index=2, before=‘NA’, after=‘’ 
# 2: MultisessionFuture (‘future_lapply-2’) added, removed, or modified devices. A future expression must close any opened devices and must not close devices it did not open. Details: 1 devices differ: index=2, before=‘NA’, after=‘’ 

[elgabbas]

The problem seems not to be from ggExtra::ggMarginal but from the ggplot2::ggplotGrob function. Please see here: tidyverse/ggplot2#6464

Is it possible to suppress this specific warning using the future.conditions argument? Does this warning have a particular class type that can be suppressed?

I used future.conditions = structure("condition", exclude = "DeviceMisuseFutureWarning") but this did not help

library(ggplot2)
library(grid)
library(future.apply)

plan(multisession, workers = 2)

plot_function <- function(x) {
  p <- ggplot(data.frame(x = rnorm(100), y = rnorm(100)), aes(x, y)) +
    geom_point()
  grob <- ggplotGrob(p)
  return(grob)
}

results <- future_lapply(
  1:5, plot_function, future.seed = TRUE,
  future.conditions = structure("condition", exclude = "DeviceMisuseFutureWarning"))
results <- future_lapply(
  1:5, plot_function, future.seed = TRUE,
  future.conditions = structure("condition", exclude = "MisuseFutureWarning"))
results <- future_lapply(
  1:5, plot_function, future.seed = TRUE,
  future.conditions = structure("condition", exclude = c("MisuseFutureWarning", "DeviceMisuseFutureWarning")))

[elgabbas]

I think I found a temporary solution that disables the DeviceMisuseFutureWarning warnings.

library(ggplot2)
library(grid)
library(ggExtra)
library(future.apply)

plan(multisession, workers = 2)

plot_function1 <- function(x) {
  warning("warning 1", call. = FALSE)
  data <- data.frame(x = rnorm(100), y = rnorm(100))
  Plot <- ggplot(data, aes(x, y)) + geom_point(color = "steelblue4")
  warning("warning 2", call. = FALSE)
  
  Plot_Marginal <- ggExtra::ggMarginal(
    p = Plot, type = "histogram", margins = "y", size = 6,
    color = "steelblue4", fill = "steelblue4", bins = 50
  )
  warning("warning 3", call. = FALSE)
  
  Plot_Marginal
}

plot_function2 <- function(x) {
  warning("warning 1", call. = FALSE)
  p <- ggplot(data.frame(x = rnorm(100), y = rnorm(100)), aes(x, y)) +
    geom_point()
  warning("warning 2", call. = FALSE)
  grob <- ggplotGrob(p)
  warning("warning 3", call. = FALSE)
  return(grob)
}

suppress_device_warning <- function(expr) {
  withCallingHandlers(
    expr,
    warning = function(w) {
      msg <- conditionMessage(w)
      if (inherits(w, "DeviceMisuseFutureWarning") ||
          grepl("added, removed, or modified devices", msg)) {
        invokeRestart("muffleWarning")
      }
    }
  )
}

# no warnings
suppress_device_warning({
  outputs1 <- future_lapply(1:5, plot_function1, future.seed = TRUE)
})

plot(outputs1[[1]])

# no warnings
suppress_device_warning({
  outputs2 <- future_lapply(1:5, plot_function2, future.seed = TRUE)
})

plot(outputs2[[1]])

[HenrikBengtsson]

The problem seems not to be from ggExtra::ggMarginal but from the ggplot2::ggplotGrob function. Please see here: tidyverse/ggplot2#6464

Agree, it appear that the graphics devices is opened by ggplot2::ggplotGrob(), which ggExtra::ggMarginal() calls internally.

Warning messages:
1: MultisessionFuture (‘future_lapply-1’) added, removed, or modified devices. A future expression must close any opened devices and must not close devices it did not open. Details: 1 devices differ: index=3, before=‘NA’, after=‘’
2: MultisessionFuture (‘future_lapply-2’) added, removed, or modified devices. A future expression must close any opened devices and must not close devices it did not open. Details: 1 devices differ: index=3, before=‘NA’, after=‘’

Thanks for the follow up. I can reproduce this using your example. It turns out that these warning messages are slightly different from the original ones. The "... devices differ: index=3, before=‘NA’, after=‘’" part triggered my attention. It turns out that there was a thinko/bug in the code comparing graphics devices before and after evaluating the future. It failed to prune off devices with empty names (after=''), which triggered this false-positive warning. I've fixed this in the develop version of future. Please retry with:

remotes::install_github("futureverse/future", ref = "develop")

Regarding your strategy to muffle these warnings:

Putting aside that the pdf(nullfile()) workaround still produced a warning was due to a bug, in general you should refrain from muffling warnings. It's much better to address the underlying problem. By muffling warnings, then you end up forgetting about the problem and it might be a ticking bomb. For example, and I haven't verified this, but if each parallel worker has a PDF device left behind, and each new future appends to this, then the produced Rplots.pdf file might keep growing in size over time until you run out of disk space.

The analogue is a bit like when you cook and the food in one of the pan is overheated producing smoke. The smoke alarm goes off. The natural instinct is to silence the smoke alarm (= muffle the warnings), but the real solution is to turn off the stove and remove the smoking pan (= prevent spurious graphics devices from being opened). It's also not uncommon that people take out the battery (= disable the checks) of the smoke alarm so they can keep cooking, but that comes with the risk of forgetting to put the battery back in when done cooking. (*) Yes, there are R options to disable these type of checks.

[elgabbas]

Thanks @HenrikBengtsson for your detailed response and example.

I installed future from GitHub. However, the warning persists. I also receive other warnings for the tibble package, which was loaded outside of future and not used inside the parallel work.

remotes::install_github("futureverse/future", ref = "develop")
# Skipping install of 'future' from a github remote, the SHA1 (472cc3fa) has not changed since last install.
# Use `force = TRUE` to force installation

library(ggplot2)
library(ggExtra)
library(magrittr)
library(tibble)
library(future.apply)

# Set up parallel processing
plan(multisession, workers = 3)

# Function to simulate plotting operation with ggExtra::ggMarginal
plot_function <- function(x) {
  (data.frame(x = rnorm(100), y = rnorm(100)) %>% 
    ggplot(aes(x, y)) +
    geom_point(color = "steelblue4")) %>% 
    ggExtra::ggMarginal(type = "histogram")
}

results <- future_lapply(
  1:5, plot_function, future.seed = TRUE,
  future.packages = c("magrittr", "ggplot", "ggExtra"))

# Warning messages:
#   1: In serialize(data, node$con, xdr = FALSE) :
#   'package:tibble' may not be available when loading
# 2: In serialize(data, node$con, xdr = FALSE) :
#   'package:tibble' may not be available when loading
# 3: In serialize(data, node$con, xdr = FALSE) :
#   'package:tibble' may not be available when loading
# 4: In serialize(data, node$con, xdr = FALSE) :
#   'package:tibble' may not be available when loading
# 5: In serialize(data, node$con, xdr = FALSE) :
#   'package:tibble' may not be available when loading
# 6: In serialize(data, node$con, xdr = FALSE) :
#   'package:tibble' may not be available when loading
# 7: MultisessionFuture (‘future_lapply-1’) added, removed, or modified devices. A future expression must close any opened devices and must not close devices it did not open. Details: 1 devices differ: index=2, before=‘NA’, after=‘pdf’ 
# 8: MultisessionFuture (‘future_lapply-2’) added, removed, or modified devices. A future expression must close any opened devices and must not close devices it did not open. Details: 1 devices differ: index=2, before=‘NA’, after=‘pdf’ 
# 9: MultisessionFuture (‘future_lapply-3’) added, removed, or modified devices. A future expression must close any opened devices and must not close devices it did not open. Details: 1 devices differ: index=2, before=‘NA’, after=‘pdf’ 

# fresh R session
results <- future_lapply(
  1:5, plot_function, future.seed = TRUE,
  future.conditions = structure("condition", exclude = "DeviceMisuseFutureWarning"))
# Warning messages:
#   1: In serialize(data, node$con, xdr = FALSE) :
#   'package:tibble' may not be available when loading
# 2: In serialize(data, node$con, xdr = FALSE) :
#   'package:tibble' may not be available when loading
# 3: In serialize(data, node$con, xdr = FALSE) :
#   'package:tibble' may not be available when loading
# 4: In serialize(data, node$con, xdr = FALSE) :
#   'package:tibble' may not be available when loading
# 5: In serialize(data, node$con, xdr = FALSE) :
#   'package:tibble' may not be available when loading
# 6: In serialize(data, node$con, xdr = FALSE) :
#   'package:tibble' may not be available when loading
# 7: MultisessionFuture (‘future_lapply-1’) added, removed, or modified devices. A future expression must close any opened devices and must not close devices it did not open. Details: 1 devices differ: index=2, before=‘NA’, after=‘pdf’ 
# 8: MultisessionFuture (‘future_lapply-2’) added, removed, or modified devices. A future expression must close any opened devices and must not close devices it did not open. Details: 1 devices differ: index=2, before=‘NA’, after=‘pdf’ 
# 9: MultisessionFuture (‘future_lapply-3’) added, removed, or modified devices. A future expression must close any opened devices and must not close devices it did not open. Details: 1 devices differ: index=2, before=‘NA’, after=‘pdf’ 

# Fresh R session
results <- future_lapply(
  1:5, plot_function, future.seed = TRUE,
  future.conditions = structure("condition", exclude = "MisuseFutureWarning"))

# Warning messages:
#   1: In serialize(data, node$con, xdr = FALSE) :
#   'package:tibble' may not be available when loading
# 2: In serialize(data, node$con, xdr = FALSE) :
#   'package:tibble' may not be available when loading
# 3: In serialize(data, node$con, xdr = FALSE) :
#   'package:tibble' may not be available when loading
# 4: In serialize(data, node$con, xdr = FALSE) :
#   'package:tibble' may not be available when loading
# 5: In serialize(data, node$con, xdr = FALSE) :
#   'package:tibble' may not be available when loading
# 6: In serialize(data, node$con, xdr = FALSE) :
#   'package:tibble' may not be available when loading
# 7: MultisessionFuture (‘future_lapply-1’) added, removed, or modified devices. A future expression must close any opened devices and must not close devices it did not open. Details: 1 devices differ: index=2, before=‘NA’, after=‘pdf’ 
# 8: MultisessionFuture (‘future_lapply-2’) added, removed, or modified devices. A future expression must close any opened devices and must not close devices it did not open. Details: 1 devices differ: index=2, before=‘NA’, after=‘pdf’ 
# 9: MultisessionFuture (‘future_lapply-3’) added, removed, or modified devices. A future expression must close any opened devices and must not close devices it did not open. Details: 1 devices differ: index=2, before=‘NA’, after=‘pdf’ 

[HenrikBengtsson]

You still need to address the underlying problem by using the

  pdf(nullfile())
  on.exit(dev.off())

workaround.

[HenrikBengtsson]

Next release will also be more informative about what's going. It will now generate an additional warning that is related to this problem, which will also help to pin down which command causes the (default) graphics device to be opened, e.g.

library(future)
library(ggplot2)

# Sample data
data <- data.frame(x = rnorm(100), y = rnorm(100))
plot <- ggplot(data, aes(x, y)) + geom_point()

f <- future({
  ggExtra::ggMarginal(p = plot, type = "histogram")
})
v <- value(f)

produces

Warning messages:

1: SequentialFuture (NULL) added, removed, or modified devices. A
future expression must close any opened devices and must not
close devices it did not open. Details: 1 devices differ:
index=2, before='NA', after='X11'. See also
help("future.options", package = "future")

2: SequentialFuture (NULL) opened the default graphics device (1:
ggExtra::ggMarginal(p = plot, type = "histogram") ->
ggplot2::ggplotGrob(scatP) -> ggplot_gtable(ggplot_build(x)) ->
...). This happens for instance if plot() is called without
explicitly opening a graphics device before. Using default
graphics devices in parallel processing will typically leave
behind a 'Rplots.pdf' file on the parallel worker. If the
intention is to plot to file, please open a graphics device
explicitly (e.g. pdf() or png()) [recommended], or set your
preferred `options(default = ...)` [not recommended], then plot,
and make sure to close it at the end (i.e. dev.off()). See also
help("future.options", package = "future")

[elgabbas]

I missed that. Thanks. This solved the issue, with no warnings on unclosed devices.

But I still have these warnings. I tested with another Windows PC and found that an earlier version of future did not show these warnings, but installing the development version from GitHub shows these warnings.

Warning messages:
1: In serialize(data, node$con, xdr = FALSE) :
  'package:tibble' may not be available when loading
2: In serialize(data, node$con, xdr = FALSE) :
  'package:tibble' may not be available when loading
3: In serialize(data, node$con, xdr = FALSE) :
  'package:tibble' may not be available when loading
4: In serialize(data, node$con, xdr = FALSE) :
  'package:tibble' may not be available when loading
5: In serialize(data, node$con, xdr = FALSE) :
  'package:tibble' may not be available when loading
6: In serialize(data, node$con, xdr = FALSE) :
  'package:tibble' may not be available when loading> 

[HenrikBengtsson]

Please open a new discussion about those serialize(data, node$con, xdr = FALSE) warnings. It'll help future visitors.

[elgabbas]

I opened a new discussion here: #790.
I will close this discussion. Thanks