New Metrics; New Vignette; update Layer(); add create_layer_wrapper()

* New vignette: Making New Layers via Subclassing

* Update metrics:
  - all the metric functions gain the ability to return a `keras$metrics$Metric`
   instance if called without `y_true` and `y_pred`
  - Each metric function is now documented separately, with a common
  `?Metric` topic demonstrating example usage.
  - New built in metrics:
      - `metric_true_negatives()`
      - `metric_true_positives()`
      - `metric_false_negatives()`
      - `metric_false_positives()`
      - `metric_specificity_at_sensitivity()`
      - `metric_sensitivity_at_specificity()`
      - `metric_precision()`
      - `metric_precision_at_recall()`
      - `metric_sum()`
      - `metric_recall()`
      - `metric_recall_at_precision()`
      - `metric_root_mean_squared_error()`
      - `metric_sparse_categorical_accuracy()`
      - `metric_mean_tensor()`
      - `metric_mean_wrapper()`
      - `metric_mean_iou()`
      - `metric_mean_relative_error()`
      - `metric_logcosh_error()`
      - `metric_mean()`
      - `metric_cosine_similarity()`
      - `metric_categorical_hinge()`
      - `metric_accuracy()`
      - `metric_auc()`

* Make `Layer()` lazy about initializing the Python session. It is now safe to use in a package.

* Add `create_layer_wrapper()`

* Restore R-3.6 compat (subtle changes in active-bindings and S3 dispatch)

* Accept install_keras(version="cpu")

* Bump github actions TF test version

Author: t-kalinowski

.github/workflows/main.yaml

@@ -34,15 +34,15 @@ jobs:
           # - {os: 'windows-latest', tf: 'release', r: 'release'}
           # - {os: 'macOS-latest'  , tf: 'release', r: 'release'}
 
-          # - {os: 'ubuntu-20.04', tf: '2.5', r: 'release'}
+          - {os: 'ubuntu-20.04', tf: '2.5', r: 'release'}
           - {os: 'ubuntu-20.04', tf: '2.4', r: 'release'}
           - {os: 'ubuntu-20.04', tf: '2.3', r: 'release'}
           - {os: 'ubuntu-20.04', tf: '2.2', r: 'release'}
           - {os: 'ubuntu-20.04', tf: '2.1', r: 'release'}
 
           # these are allowed to fail
           - {os: 'ubuntu-20.04', tf: 'default', r: 'devel'}
-          - {os: 'ubuntu-20.04', tf: '2.6.0rc2', r: 'release'}
+          # - {os: 'ubuntu-20.04', tf: '2.6.0rc2', r: 'release'}
           # - {os: 'ubuntu-20.04', tf: 'nightly' , r: 'release'}
 
     runs-on: ${{ matrix.os }}

NAMESPACE

@@ -54,6 +54,7 @@ S3method(py_str,keras.engine.training.Model)
 S3method(py_to_r_wrapper,keras.engine.training.Model)
 S3method(py_to_r_wrapper,kerastools.model.RModel)
 S3method(r_to_py,R6ClassGenerator)
+S3method(r_to_py,keras_layer_wrapper)
 S3method(round,keras.engine.keras_tensor.KerasTensor)
 S3method(sign,keras.engine.keras_tensor.KerasTensor)
 S3method(sin,keras.engine.keras_tensor.KerasTensor)
@@ -121,6 +122,7 @@ export(constraint_nonneg)
 export(constraint_unitnorm)
 export(count_params)
 export(create_layer)
+export(create_layer_wrapper)
 export(create_wrapper)
 export(custom_metric)
 export(dataset_boston_housing)
@@ -588,6 +590,7 @@ importFrom(reticulate,tuple)
 importFrom(reticulate,use_condaenv)
 importFrom(reticulate,use_python)
 importFrom(reticulate,use_virtualenv)
+importFrom(rlang,"%||%")
 importFrom(stats,predict)
 importFrom(tensorflow,evaluate)
 importFrom(tensorflow,export_savedmodel)

NEWS.md

@@ -1,55 +1,49 @@
 # keras (development version)
 
 Breaking changes:
-`set_vocabulary()` arguments `df_data` and `oov_df_value` are deprecated. They are superseded by the new argument `idf_weights`.
 
-TF 2.6 changes:
-- `predict_proba` and `predict_classes` were removed.
+- `predict_proba()` and `predict_classes()` were removed.
 - model serialization to/from yaml was removed.
 - default changed: `layer_text_vectorization(pad_to_max_tokens=FALSE)`
+- `set_vocabulary()` arguments `df_data` and `oov_df_value` are deprecated. They are superseded by the new argument `idf_weights`.
 
 New Features:
-- Default Tensorflow/Keras version is now 2.6
 
-- The `keras` python module is exported
+- Default Tensorflow/Keras version is now 2.6
 
-- Introduced `%py_class%`, a new python class generator constructor.
+- Introduced `%py_class%`, an R-language constructor for Python classes.
 
 - New vignettes:
-  - Subclassing python classes: How to use `%py_class%`.
+  - Subclassing Python classes: How to use `%py_class%`.
+  - Making new layers and models via subclassing.
   - Customizing what happens in fit (example of how to define a model, like a GAN, with a custom train step).
   - Writing your own callbacks.
 
-- All optimizer had argument `lr` renamed to `learning_rate`.
-  (backwards compatibility is preserved, an R warning is now issued).
-
-- keras now imports the glue package
-
-- The `compile()` method for keras models has been updated:
-  - `optimizer` is now an optional argument. It defaults to "rmsprop" for regular keras models. Custom models can specify their own default optimizer.
-  - `loss` is now an optional argument.
-  - New optional arguments: `run_eagerly`, `steps_per_execution`.
-  - `target_tensors` and `sample_weight_mode` must now be supplied as named arguments.
+- The `keras` Python module is exported
 
 - Major changes to the underlying handling of custom R6 layer classes.
-  - A new `r_to_py` method is provided for `R6ClassGenerator` objects.
-  - R6 custom layers can now inherit directly from python layer classes
-    or other R6 custom layer classes
-  - Custom R6 layers can now be instantiated directly after conversion of the class generator with `r_to_py`, without going through `create_layer`.
-  - `KerasLayer` is deprecated (new classes should inherit directly from `keras$layers$Layer`)
-  - `KerasWrapper` is deprecated (new classes should inherit directly from `keras$layers$Wrapper`)
-  - `create_wrapper` is deprecated (no longer needed, use `create_layer` directly)
-  - All layer class methods provided as R functions now have a `super` in scope that resolves to the python super class object
+  - A new `r_to_py()` method is provided for `R6ClassGenerator` objects.
+  - R6 custom layers can now inherit directly from Python layer classes
+    or other R6 custom layer classes.
+  - Custom R6 layers can now be instantiated directly after conversion of the class generator with `r_to_py()`, without going through `create_layer()`.
+  - `KerasLayer` is deprecated (new classes should inherit directly from `keras$layers$Layer`).
+  - `KerasWrapper` is deprecated (new classes should inherit directly from `keras$layers$Wrapper`).
+  - `create_wrapper()` is deprecated (no longer needed, use `create_layer()` directly).
+  - All layer class methods provided as R functions now have a `super` in scope that resolves to the Python super class object.
   - Methods of `super` can be accessed in the 3 common ways:
-      (python3 style): `super()$"__init__"()`
-      (python2 style): `super(ClassName, self)$"__init__"()`
-      (R6 style): `super$initialize()`
-  - User defined custom classes that inherit from a python type are responsible for calling `super()$__init__(...)` if appropriate.
+    - (Python 3 style): `super()$"__init__"()`
+    - (Python 2 style): `super(ClassName, self)$"__init__"()`
+    - (R6 style): `super$initialize()`
+  - User defined custom classes that inherit from a Python type are responsible for calling ```super()$`__init__`(...)``` if appropriate.
   - Custom layers can now properly handle masks (#1225)
     - `supports_masking = TRUE` attribute is now supported
     - `compute_mask()` user defined method is now supported
   - `call()` methods now support a `training` argument, as well as any additional arbitrary user-defined arguments
 
+- `Layer()` custom layer constructor is now lazy about initializing the Python session and safe to use on the top level of an R package (#1229).
+
+- New function `create_layer_wrapper()` that can create a composing R function wrapper around a custom layer class.
+
 - Refactored `install_keras()` (along with `tensorflow::install_tensorflow()`).
   Installation should be more reliable for more users now.
   If you encounter installation issues, please file an issue: https://github.com/rstudio/keras/issues/new
@@ -58,50 +52,49 @@ New Features:
 
   - pandas is now a default extra packages installed by `install_keras()`
 
-- loss functions:
-  - all the loss functions gain the ability to return a callable
+- Loss functions:
+  - All the loss functions gain the ability to return a callable
     (a `keras$losses$Loss` instance) if `y_true` and `y_pred` arguments are missing.
-  - new builtin loss functions: loss_huber(), loss_kl_divergence()
+  - New builtin loss functions:
 
-- metric functions:
-  - all the metric functions gain the ability to return a `keras$metrics$Metric` instance if called without `y_true` and `y_pred`
+      -  `loss_huber()`
+      -  `loss_kl_divergence()`
+
+- Metric functions:
+  - All the metric functions gain the ability to return a `keras$metrics$Metric` instance if called without `y_true` and `y_pred`
   - Each metric function is now documented separately, with a common `?Metric` topic demonstrating example usage.
-  - New built in metrics:
-        metric_true_negatives
-        metric_true_positives
-        metric_false_negatives
-        metric_false_positives
-        metric_specificity_at_sensitivity
-        metric_sensitivity_at_specificity
-        metric_precision
-        metric_precision_at_recall
-        metric_sum
-        metric_recall
-        metric_recall_at_precision
-        metric_root_mean_squared_error
-        metric_sparse_categorical_accuracy
-        metric_mean_tensor
-        metric_mean_wrapper
-        metric_mean_iou
-        metric_mean_relative_error
-        metric_logcosh_error
-        metric_mean
-        metric_cosine_similarity
-        metric_categorical_hinge
-        metric_accuracy
-        metric_auc
-
-- keras_model_sequential() gains the ability to accept arguments that
-  define input layer like `input_shape` and `dtype`.
+  - New built-in metrics:
+
+      -  `metric_true_negatives()`
+      -  `metric_true_positives()`
+      -  `metric_false_negatives()`
+      -  `metric_false_positives()`
+      -  `metric_specificity_at_sensitivity()`
+      -  `metric_sensitivity_at_specificity()`
+      -  `metric_precision()`
+      -  `metric_precision_at_recall()`
+      -  `metric_sum()`
+      -  `metric_recall()`
+      -  `metric_recall_at_precision()`
+      -  `metric_root_mean_squared_error()`
+      -  `metric_sparse_categorical_accuracy()`
+      -  `metric_mean_tensor()`
+      -  `metric_mean_wrapper()`
+      -  `metric_mean_iou()`
+      -  `metric_mean_relative_error()`
+      -  `metric_logcosh_error()`
+      -  `metric_mean()`
+      -  `metric_cosine_similarity()`
+      -  `metric_categorical_hinge()`
+      -  `metric_accuracy()`
+      -  `metric_auc()`
+
+- `keras_model_sequential()` gains the ability to accept arguments that
+  define the input layer like `input_shape` and `dtype`.
   See `?keras_model_sequential` for details and examples.
 
-- Refactored automated tests to closer match the default installation procedure
-  and compute environment of most user.
-
-- Expanded CI test coverage to include R devel, oldrel and 3.6.
-
 - Many layers gained new arguments, coming to parity with the interface
-  available in the latest python version:
+  available in the latest Python version:
 
     | layer name                   | new argument     |
     |------------------------------|------------------|
@@ -119,11 +112,28 @@ New Features:
     | `layer_text_vectorization`   | `vocabulary`     |
 
 
+- The `compile()` method for keras models has been updated:
+  - `optimizer` is now an optional argument. It defaults to `"rmsprop"` for regular keras models.
+     Custom models can specify their own default optimizer.
+  - `loss` is now an optional argument.
+  - New optional arguments: `run_eagerly`, `steps_per_execution`.
+  - `target_tensors` and `sample_weight_mode` must now be supplied as named arguments.
 
 - Added activation functions swish and gelu. (#1226)
 
 - `set_vocabulary()` gains a `idf_weights` argument.
 
+- All optimizer had argument `lr` renamed to `learning_rate`.
+  (backwards compatibility is preserved, an R warning is now issued).
+
+- The glue package was added to Imports
+
+- Refactored automated tests to closer match the default installation procedure
+  and compute environment of most user.
+
+- Expanded CI test coverage to include R devel, oldrel and 3.6.
+
+
 # keras 2.4.0
 
 - Use compat module when using `set_session` and `get_session`. (#1046)

R/Layer.R

@@ -62,68 +62,26 @@ Layer <- function(classname, initialize, build = NULL, call = NULL,
                   compute_output_shape = NULL, ...,
                   inherit = tensorflow::tf$keras$layers$Layer) {
 
+  inherit <- substitute(inherit)
 
-  defs <- list(
-    initialize = initialize,
-    build = build,
-    call = call,
-    compute_output_shape = compute_output_shape
-  )
-  defs <- Filter(Negate(is.null), defs)
-  defs <- append(defs, list(...))
+  public <- list(...)
+  public$initialize <- initialize
+  public$build <- build
+  public$call <- call
+  public$compute_output_shape <- compute_output_shape
 
+  parent_env <- parent.frame()
 
-  # allow using the initialize method
-  if ("initialize" %in% names(defs)) {
-    if (!is.null(defs$`__init__`))
-      stop("You should not specify both __init__ and initialize methods.", call.=FALSE)
-
-    defs[["__init__"]] <- defs$initialize
-  }
-
-  # automatically add the `self` argument
-  defs <- lapply(defs, function(x) {
-
-    if (inherits(x, "function")) {
-     formals(x) <- append(
-       pairlist(self = NULL),
-       formals(x)
-     )
-    }
-
-    x
-  })
-
-  # makes the function return NULL. `__init__` in python must always return None
-  defs$`__init__` <- wrap_return_null(defs$`__init__`)
-
-  # allow inheriting from custom created layers
-  if (!is.null(attr(inherit, "layer")))
-    inherit <- attr(inherit, "layer")
-
-  layer <- reticulate::PyClass(
+  # R6Class() calls substitute() on inherit;
+  r_cls <- eval(as.call(list(
+    quote(R6::R6Class),
     classname = classname,
-    defs = defs,
-    inherit = inherit
-  )
-  layer$`__module__` <- classname
-
-  # build the function to be used
-  f <- function(object) {
-    .args <- as.list(match.call())[-c(1)]
-    .args <- .args[names(.args) != "object"]
-    create_layer(layer, object, .args)
-  }
-  formals(f) <- append(
-    formals(f),
-    formals(initialize)
-  )
-  attr(f, "layer") <- layer
-  f
-}
+    public = public,
+    active = NULL,
+    inherit = inherit,
+    cloneable = FALSE,
+    parent_env = parent_env
+  )))
 
-# makes the function return NULL. `__init__` in python must always return None.
-wrap_return_null <- function(f) {
-  body(f)[[length(body(f)) + 1]] <- substitute(return(NULL))
-  f
+  create_layer_wrapper(r_cls)
 }