layer_merge() family can accept layers in ...

Author: t-kalinowski

NAMESPACE

@@ -617,6 +617,7 @@ importFrom(reticulate,use_condaenv)
 importFrom(reticulate,use_python)
 importFrom(reticulate,use_virtualenv)
 importFrom(rlang,"%||%")
+importFrom(rlang,names2)
 importFrom(stats,predict)
 importFrom(tensorflow,as_tensor)
 importFrom(tensorflow,evaluate)

NEWS.md

@@ -2,6 +2,16 @@
 
 - New `callback_backup_and_restore()`, for resuming an interrupted `fit()` call.
 
+- The merging family of layers (`layer_add`, `layer_concatenate`, etc.) gain the ability
+  to accept layers in `...`, allowing for easier composition of residual blocks with the pipe `%>%`.
+  e.g. something like this now works:
+  ```r
+  block_1_output <- ...
+  block_2_output <- block_1_output %>% 
+    layer_conv_2d(64, 3, activation = "relu", padding = "same") %>% 
+    layer_add(block_1_output)
+  ```
+  
 # keras 2.9.0
 
 - New functions for constructing custom keras subclasses:

R/layers-merge.R

@@ -5,8 +5,8 @@
 #' It takes as input a list of tensors, all of the same shape, and returns a
 #' single tensor (also of the same shape).
 #'
-#' @param inputs A list of input tensors (at least 2). Can be missing.
-#' @param ... Standard layer arguments (must be named).
+#' @param inputs A input tensor, or list of input tensors. Can be missing.
+#' @param ... Unnamed args are treated as additional `inputs`. Named arguments are passed on as standard layer arguments.
 #'
 #' @return A tensor, the sum of the inputs. If `inputs` is missing, a keras
 #'   layer instance is returned.
@@ -15,16 +15,20 @@
 #'
 #' @seealso
 #' +  <https://www.tensorflow.org/api_docs/python/tf/keras/layers/add>
-#' +  <https://www.tensorflow.org/api_docs/python/tf/keras/layers/Add>
 #' +  <https://keras.io/api/layers/merging_layers/add>
 #'
 #' @export
 layer_add <- function(inputs, ...) {
-  callable <- if(missing(inputs)) keras$layers$Add else keras$layers$add
-  args <- capture_args(match.call(), list(batch_size = as_nullable_integer))
-  do.call(callable, args)
+  if (missing(inputs))
+    return(keras$layers$Add(...))
+  if (!is.list(inputs))
+    inputs <- list(inputs)
+  dots <- split_dots_named_unnamed(list(...))
+  inputs <- c(inputs, dots$unnamed)
+  do.call(keras$layers$add, c(list(inputs), dots$named))
 }
 
+
 # TODO: there should be a common topic where we can use
 # @inheritDotParams standard-layer-args
 
@@ -35,8 +39,8 @@ layer_add <- function(inputs, ...) {
 #' returns a single tensor, (`inputs[[1]] - inputs[[2]]`), also of the same
 #' shape.
 #'
-#' @param inputs A list of input tensors (exactly 2). Can be missing.
-#' @param ... Standard layer arguments (must be named).
+#' @param inputs A input tensor, or list of two input tensors. Can be missing.
+#' @param ... Unnamed args are treated as additional `inputs`. Named arguments are passed on as standard layer arguments.
 #'
 #' @return A tensor, the difference of the inputs. If `inputs` is missing, a
 #'   keras layer instance is returned.
@@ -46,23 +50,27 @@ layer_add <- function(inputs, ...) {
 #'
 #' @seealso
 #' +  <https://www.tensorflow.org/api_docs/python/tf/keras/layers/subtract>
-#' +  <https://www.tensorflow.org/api_docs/python/tf/keras/layers/Subtract>
 #' +  <https://keras.io/api/layers/merging_layers/subtract>
 #'
 #' @export
 layer_subtract <- function(inputs, ...) {
-  callable <- if (missing(inputs)) keras$layers$Subtract else keras$layers$subtract
-  args <- capture_args(match.call(), list(batch_size = as_nullable_integer))
-  do.call(callable, args)
+  if (missing(inputs))
+    return(keras$layers$Subtract(...))
+  if (!is.list(inputs))
+    inputs <- list(inputs)
+  dots <- split_dots_named_unnamed(list(...))
+  inputs <- c(inputs, dots$unnamed)
+  do.call(keras$layers$subtract, c(list(inputs), dots$named))
 }
 
+
 #' Layer that multiplies (element-wise) a list of inputs.
 #'
 #' It takes as input a list of tensors, all of the same shape, and returns a
 #' single tensor (also of the same shape).
 #'
-#' @param inputs A list of input tensors (at least 2). Can be missing.
-#' @param ... Standard layer arguments (must be named).
+#' @param inputs A input tensor, or list of input tensors. Can be missing.
+#' @param ... Unnamed args are treated as additional `inputs`. Named arguments are passed on as standard layer arguments.
 #'
 #' @return A tensor, the element-wise product of the inputs. If `inputs` is
 #'   missing, a keras layer instance is returned.
@@ -72,15 +80,17 @@ layer_subtract <- function(inputs, ...) {
 #'
 #' @seealso
 #' +  <https://www.tensorflow.org/api_docs/python/tf/keras/layers/multiply>
-#' +  <https://www.tensorflow.org/api_docs/python/tf/keras/layers/Multiply>
 #' +  <https://keras.io/api/layers/merging_layers/multiply>
 #'
 #' @export
 layer_multiply <- function(inputs, ...) {
-  callable <- if (missing(inputs)) keras$layers$Multiply else keras$layers$multiply
-  args <- capture_args(match.call(), list(batch_size = as_nullable_integer))
-  do.call(callable, args)
-
+  if (missing(inputs))
+    return(keras$layers$Multiply(...))
+  if (!is.list(inputs))
+    inputs <- list(inputs)
+  dots <- split_dots_named_unnamed(list(...))
+  inputs <- c(inputs, dots$unnamed)
+  do.call(keras$layers$multiply, c(list(inputs), dots$named))
 }
 
 
@@ -89,8 +99,8 @@ layer_multiply <- function(inputs, ...) {
 #' It takes as input a list of tensors, all of the same shape, and returns a
 #' single tensor (also of the same shape).
 #'
-#' @param inputs A list of input tensors (at least 2). Can be missing.
-#' @param ... Standard layer arguments (must be named).
+#' @param inputs A input tensor, or list of input tensors. Can be missing.
+#' @param ... Unnamed args are treated as additional `inputs`. Named arguments are passed on as standard layer arguments.
 #'
 #' @return A tensor, the average of the inputs. If `inputs` is missing, a keras
 #'   layer instance is returned.
@@ -105,19 +115,22 @@ layer_multiply <- function(inputs, ...) {
 #'
 #' @export
 layer_average <- function(inputs, ...) {
-  callable <- if (missing(inputs)) keras$layers$Average else keras$layers$average
-  args <- capture_args(match.call(), list(batch_size = as_nullable_integer))
-  do.call(callable, args)
-
+  if (missing(inputs))
+    return(keras$layers$Average(...))
+  if (!is.list(inputs))
+    inputs <- list(inputs)
+  dots <- split_dots_named_unnamed(list(...))
+  inputs <- c(inputs, dots$unnamed)
+  do.call(keras$layers$average, c(list(inputs), dots$named))
 }
 
 #' Layer that computes the maximum (element-wise) a list of inputs.
 #'
 #' It takes as input a list of tensors, all of the same shape, and returns a
 #' single tensor (also of the same shape).
 #'
-#' @param inputs A list of input tensors (at least 2). Can be missing.
-#' @param ... Standard layer arguments (must be named).
+#' @param inputs A input tensor, or list of input tensors. Can be missing.
+#' @param ... Unnamed args are treated as additional `inputs`. Named arguments are passed on as standard layer arguments.
 #'
 #' @return A tensor, the element-wise maximum of the inputs. If `inputs` is
 #'   missing, a keras layer instance is returned.
@@ -132,10 +145,13 @@ layer_average <- function(inputs, ...) {
 #'
 #' @export
 layer_maximum <- function(inputs, ...) {
-  callable <- if (missing(inputs)) keras$layers$Maximum else keras$layers$maximum
-  args <- capture_args(match.call(), list(batch_size = as_nullable_integer))
-  do.call(callable, args)
-
+  if (missing(inputs))
+    return(keras$layers$Maximum(...))
+  if (!is.list(inputs))
+    inputs <- list(inputs)
+  dots <- split_dots_named_unnamed(list(...))
+  inputs <- c(inputs, dots$unnamed)
+  do.call(keras$layers$maximum, c(list(inputs), dots$named))
 }
 
 
@@ -144,8 +160,8 @@ layer_maximum <- function(inputs, ...) {
 #' It takes as input a list of tensors, all of the same shape, and returns a
 #' single tensor (also of the same shape).
 #'
-#' @param inputs A list of input tensors (at least 2). Can be missing.
-#' @param ... Standard layer arguments (must be named).
+#' @param inputs A input tensor, or list of input tensors. Can be missing.
+#' @param ... Unnamed args are treated as additional `inputs`. Named arguments are passed on as standard layer arguments.
 #'
 #' @return A tensor, the element-wise maximum of the inputs. If `inputs` is
 #'   missing, a keras layer instance is returned.
@@ -159,9 +175,13 @@ layer_maximum <- function(inputs, ...) {
 #'
 #' @export
 layer_minimum <- function(inputs, ...) {
-  callable <- if (missing(inputs)) keras$layers$Minimum else keras$layers$minimum
-  args <- capture_args(match.call(), list(batch_size = as_nullable_integer))
-  do.call(callable, args)
+  if (missing(inputs))
+    return(keras$layers$Minimum(...))
+  if (!is.list(inputs))
+    inputs <- list(inputs)
+  dots <- split_dots_named_unnamed(list(...))
+  inputs <- c(inputs, dots$unnamed)
+  do.call(keras$layers$minimum, c(list(inputs), dots$named))
 }
 
 
@@ -171,9 +191,9 @@ layer_minimum <- function(inputs, ...) {
 #' concatenation axis, and returns a single tensor, the concatenation of all
 #' inputs.
 #'
-#' @param inputs A list of input tensors (at least 2). Can be missing.
+#' @param inputs A input tensor, or list of input tensors. Can be missing.
+#' @param ... Unnamed args are treated as additional `inputs`. Named arguments are passed on as standard layer arguments.
 #' @param axis Concatenation axis.
-#' @param ... Standard layer arguments (must be named).
 #'
 #' @return A tensor, the concatenation of the inputs alongside axis `axis`. If
 #'   `inputs` is missing, a keras layer instance is returned.
@@ -186,23 +206,43 @@ layer_minimum <- function(inputs, ...) {
 #' +  <https://keras.io/api/layers/merging_layers/concatenate>
 #'
 #' @export
-layer_concatenate <- function(inputs, axis = -1, ...) {
-  callable <- if (missing(inputs)) keras$layers$Concatenate else keras$layers$concatenate
-  # TODO: this axis should probably be 1-based
-  args <- capture_args(match.call(), list(batch_size = as_nullable_integer,
-                                          axis = as.integer))
-  do.call(callable, args)
+layer_concatenate <- function(inputs, ..., axis = -1) {
+  if (missing(inputs)) {
+    args <- capture_args(match.call(), list(axis = as.integer))
+    return(do.call(keras$layers$Concatenate, args))
+  }
+
+  # TODO: this axis arg should probably be 1-based
+
+  if (is.list(inputs)) {
+    # backcompat: axis used to be in 2nd position, inputs used to accept only a list.
+
+    dots <- list(...)
+    if (length(dots) && names2(dots)[[1]] == "" &&
+        missing(axis) &&
+        is.numeric(dots[[1L]]) &&
+        is_scalar(dots[[1L]])) {
+      axis <- as.integer(dots[[1L]])
+      dots[[1L]] <- NULL
+    }
+    return(do.call(keras$layers$concatenate,
+                   c(list(inputs), dots, axis = as.integer(axis))))
+  }
+
+  dots <- split_dots_named_unnamed(list(...))
+  inputs <- c(list(inputs), dots$unnamed)
+  do.call(keras$layers$concatenate, c(list(inputs), dots$named))
 }
 
 #' Layer that computes a dot product between samples in two tensors.
 #'
-#' @param inputs A list of input tensors (at least 2). Can be missing.
+#' @param inputs A input tensor, or list of input tensors. Can be missing.
+#' @param ... Unnamed args are treated as additional `inputs`. Named arguments are passed on as standard layer arguments.
 #' @param axes Integer or list of integers, axis or axes along which to take the
 #'   dot product.
 #' @param normalize Whether to L2-normalize samples along the dot product axis
 #'   before taking the dot product. If set to TRUE, then the output of the dot
 #'   product is the cosine proximity between the two samples.
-#' @param ... Standard layer arguments (must be named).
 #'
 #' @return If `inputs` is supplied: A tensor, the dot product of the samples
 #'   from the inputs. If `inputs` is missing, a keras layer instance is
@@ -213,13 +253,41 @@ layer_concatenate <- function(inputs, axis = -1, ...) {
 #'
 #' @seealso
 #' +  <https://www.tensorflow.org/api_docs/python/tf/keras/layers/dot>
-#' +  <https://www.tensorflow.org/api_docs/python/tf/keras/layers/Dot>
 #' +  <https://keras.io/api/layers/merging_layers/dot/>
 #'
 #' @export
-layer_dot <- function(inputs, axes, normalize = FALSE, ...) {
-  callable <- if (missing(inputs)) keras$layers$Dot else keras$layers$dot
-  args <- capture_args(match.call(), list(batch_size = as_nullable_integer,
-                                          axes = as.integer))
-  do.call(callable, args)
+#' @importFrom rlang names2
+layer_dot <- function(inputs, ..., axes, normalize = FALSE) {
+  if (missing(inputs)) {
+    args <- capture_args(match.call(), list(axes = as.integer))
+    return(do.call(keras$layers$Dot, args))
+  }
+
+  if (is.list(inputs)) {
+    # backcompat: inputs used to only accept a list of layers, and
+    # axis, normalize, used to be in 2nd, 3rd position.
+    dots <- list(...)
+    if (length(dots) && names2(dots)[[1]] == "" &&
+        missing(axes)) {
+      axes <- as.integer(dots[[1L]])
+      dots[[1L]] <- NULL
+    }
+    if (length(dots) && names2(dots)[[1]] == "" &&
+        missing(normalize)) {
+      normalize  <- as.integer(dots[[1L]])
+      dots[[1L]] <- NULL
+    }
+    args <- c(list(inputs), dots,
+              axes = as.integer(axes), normalize = normalize)
+    return(do.call(keras$layers$dot, args))
+  }
+
+  # inputs is not a list
+  dots <- split_dots_named_unnamed(list(...))
+  inputs <- c(inputs, dots$unnamed)
+  args <- c(list(inputs),
+            dots$named,
+            axes = as.integer(axes),
+            normalize = normalize)
+  do.call(keras$layers$dot, args)
 }

R/utils.R

@@ -418,6 +418,14 @@ is_keras_tensor <- function(x) {
 }
 
 
+split_dots_named_unnamed <- function(dots) {
+  nms <- names(dots)
+  if (is.null(nms))
+    return(list(unnamed = dots, named = list()))
+  named <- nzchar(nms)
+  list(unnamed = dots[!named], named = dots[named])
+}
+
 
 assert_all_dots_named <- function(envir = parent.frame(), cl) {
 
@@ -437,6 +445,8 @@ assert_all_dots_named <- function(envir = parent.frame(), cl) {
 # TODO: should there be some default modifiers in capture_args() for standard layer args
 # like, input_shape, batch_input_shape, etc.
 
+
+
 capture_args <- function(cl, modifiers = NULL, ignore = NULL,
                          envir = parent.frame(), fn = sys.function(-1)) {
 

keras.Rproj

@@ -17,6 +17,5 @@ StripTrailingWhitespace: Yes
 
 BuildType: Package
 PackageUseDevtools: Yes
-PackageCleanBeforeInstall: Yes
 PackageInstallArgs: --no-multiarch --with-keep.source
 PackageRoxygenize: rd,collate,namespace