Merge pull request #1489 from rstudio/use-py_require

Use `py_require()` to declare Python dependencies.

Author: t-kalinowski

DESCRIPTION

@@ -29,7 +29,7 @@ Depends:
     R (>= 4.0)
 Imports:
     generics (>= 0.0.1),
-    reticulate (>= 1.36.0),
+    reticulate (>= 1.40.0.9000),
     tensorflow (>= 2.16.0),
     tfruns (>= 1.5.2),
     magrittr,
@@ -54,3 +54,5 @@ Suggests:
     jpeg
 RoxygenNote: 7.3.2
 VignetteBuilder: knitr
+Remotes:  
+    rstudio/reticulate

NEWS.md

@@ -1,5 +1,11 @@
 # keras3 (development version)
 
+- Keras now uses `reticulate::py_require()` to resolve Python dependencies.
+  Calling `install_keras()` is no longer required (but is still supported).
+  
+- `use_backend()` gains a `gpu` argument, to specify if a GPU-capable set of 
+  dependencies should be resolved by `py_require()`. 
+
 - The progress bar in `fit()`, `evaluate()` and `predict()` now 
   defaults to not presenting during testthat tests.
 

R/install.R

@@ -127,6 +127,7 @@ is_linux <- function() {
 #' Configure a Keras backend
 #'
 #' @param backend string, can be `"tensorflow"`, `"jax"`, `"numpy"`, or `"torch"`.
+#' @param gpu bool, whether to use the GPU.
 #'
 #' @details
 #' These functions allow configuring which backend keras will use.
@@ -143,20 +144,153 @@ is_linux <- function() {
 #' ```
 #' @returns Called primarily for side effects. Returns the provided `backend`, invisibly.
 #' @export
-use_backend <- function(backend) {
+use_backend <- function(backend, gpu = NA) {
 
   if (is_keras_loaded()) {
     if (config_backend() != backend)
       stop("The keras backend must be set before keras has inititialized. Please restart the R session.")
   }
+
   Sys.setenv(KERAS_BACKEND = backend)
 
-  if (reticulate::py_available())
+  if (reticulate::py_available()) {
     reticulate::import("os")$environ$update(list(KERAS_BACKEND = backend))
+  }
+
+
+  switch(
+    paste0(get_os(), "_", backend),
+
+    macOS_tensorflow = {
+
+      if (is.na(gpu))
+        gpu <- TRUE
+
+      if (gpu) {
+        py_require("tensorflow", action = "remove")
+        py_require(c("tensorflow-macos", "tensorflow-metal"), python_version = "<3.12")
+      } else {
+        py_require(action = "remove", c("tensorflow-macos", "tensorflow-metal"))
+        py_require("tensorflow")
+      }
+
+    },
+
+    macOS_jax = {
+
+      py_require(c("tensorflow-metal", "tensorflow-macos"),
+                 action = "remove")
+
+      if (is.na(gpu))
+        gpu <- TRUE
+
+      if (gpu) {
+        py_require(c("tensorflow", "jax", "jax-metal"))
+      } else {
+        py_require("tensorflow", "jax[cpu]")
+      }
+    },
+
+    macOS_torch = {
+      if(isTRUE(gpu))
+        warning("GPU usage not supported on macOS. Please use a different backend to use the GPU (jax)")
+
+      py_require(c("tensorflow-metal", "tensorflow-macos"),
+                 action = "remove")
+
+      py_require(c("tensorflow", "torch", "torchvision", "torchaudio"))
+    },
+
+    macOS_numpy = {
+      py_require(c("tensorflow-metal", "tensorflow-macos"), action = "remove")
+      py_require(c("tensorflow", "numpy"))
+    },
+
+    Linux_tensorflow = {
+
+      if (is.na(gpu))
+        gpu <- has_gpu()
+
+      if (gpu) {
+        py_require(action = "remove", c("tensorflow", "tensorflow-cpu"))
+        py_require("tensorflow[and-cuda]")
+      } else {
+        py_require(action = "remove", c("tensorflow", "tensorflow[and-cuda]"))
+        py_require("tensorflow-cpu")
+      }
+    },
+
+    Linux_jax = {
+      py_require(c("tensorflow", "tensorflow[and-cuda]"),
+                 action = "remove")
+
+      if (is.na(gpu))
+        gpu <- has_gpu()
+
+      if (gpu) {
+        py_require(c("tensorflow-cpu", "jax[cuda12]"))
+      } else {
+        py_require(c("tensorflow-cpu", "jax[cpu]"))
+      }
+    },
+
+    Linux_torch = {
+      py_require(c("tensorflow", "tensorflow[and-cuda]"), action = "remove")
+
+      if (is.na(gpu))
+        gpu <- has_gpu()
+
+      if (gpu) {
+        py_require(c("tensorflow-cpu", "torch", "torchvision", "torchaudio"))
+      } else {
+        Sys.setenv("UV_INDEX" = "https://download.pytorch.org/whl/cpu")
+        py_require(c("tensorflow-cpu", "torch", "torchvision", "torchaudio"))
+                   # additional_args = c("--index", "https://download.pytorch.org/whl/cpu"))
+      }
+    },
+
+    Linux_numpy = {
+      py_require(c("tensorflow", "tensorflow[and-cuda]"), action = "remove")
+      py_require(c("tensorflow-cpu", "numpy"))
+    },
+
+    Windows_tensorflow = {
+      if(isTRUE(gpu)) warning("GPU usage not supported on Windows. Please use WSL.")
+      py_require("tensorflow")
+    },
+
+    Windows_jax = {
+      if(isTRUE(gpu)) warning("GPU usage not supported on Windows. Please use WSL.")
+      py_require("jax")
+    },
+
+    Windows_torch = {
+      if (is.na(gpu))
+        gpu <- has_gpu()
+
+      if (gpu) {
+        Sys.setenv("UV_INDEX" = "https://download.pytorch.org/whl/cu126")
+        py_require(c("torch", "torchvision", "torchaudio"))
+                   # additional_args = c("--index", "https://download.pytorch.org/whl/cu126"))
+      } else {
+        py_require(c("torch", "torchvision", "torchaudio"))
+      }
+    },
+
+    Windows_numpy = {
+      py_require("numpy")
+    }
+  )
+
   invisible(backend)
 }
 
 
+
+get_os <- function() {
+  if (is_windows()) "Windows" else if (is_mac_arm64()) "macOS" else "Linux"
+}
+
 is_keras_loaded <- function() {
   # package .onLoad() has run (can be FALSE if in devtools::load_all())
   !is.null(keras) &&
@@ -171,6 +305,64 @@ is_keras_loaded <- function() {
 }
 
 
+has_gpu <- function() {
+
+  has_nvidia_gpu <- function() {
+    lspci_listed <- tryCatch(
+      as.logical(length(
+        system("lspci | grep -i nvidia", intern = TRUE)
+      )),
+      # warning emitted by system for non-0 exit status
+      warning = function(w) FALSE,
+      error = function(e) FALSE
+    )
+
+    if (lspci_listed)
+      return(TRUE)
+
+    # lspci doens't list GPUs on WSL Linux, but nvidia-smi does.
+    nvidia_smi_listed <- tryCatch(
+      system("nvidia-smi -L", intern = TRUE),
+      warning = function(w) character(),
+      error = function(e) character()
+    )
+    if (isTRUE(any(grepl("^GPU [0-9]: ", nvidia_smi_listed))))
+      return(TRUE)
+    FALSE
+  }
+
+  is_linux() && has_nvidia_gpu()
+
+}
+
+
+get_py_requirements <- function() {
+  python_version <- ">=3.10"
+  packages <- "tensorflow"
+
+  if(is_linux()) {
+
+    if(has_gpu()) {
+      packages <- "tensorflow[and-cuda]"
+    } else {
+      packages <- "tensorflow-cpu"
+    }
+
+  } else if (is_mac_arm64()) {
+
+    use_gpu <- FALSE
+    if (use_gpu) {
+      packages <- c("tensorflow-macos", "tensorflow-metal")
+      python_version <- ">=3.9,<=3.11"
+    }
+
+  } else if (is_windows()) {
+
+  }
+
+  list(packages = packages, python_version = python_version)
+}
+
 
 python_module_dir <- function(python, module, stderr = TRUE) {
 

R/package.R

@@ -61,6 +61,13 @@ keras <- NULL
   if (!is.null(keras_python))
     Sys.setenv(RETICULATE_PYTHON = keras_python)
 
+  # default backend is tensorflow for now
+  # the tensorflow R package calls `py_require()` to ensure GPU is usable on Linux
+  py_require(c(
+    "keras", "pydot", "scipy", "pandas", "Pillow",
+    "ipython", "tensorflow_datasets"
+  ))
+
   # delay load keras
   try(keras <<- import("keras", delay_load = list(