Introducing Keras 3 for R

We’re thrilled to introduce keras3, the subsequent model of the Keras R
bundle. keras3 is a ground-up rebuild of {keras}, sustaining the
beloved options of the unique whereas refining and simplifying the API
primarily based on invaluable insights gathered over the previous few years.

Keras gives a whole toolkit for constructing deep studying fashions in
R—it’s by no means been simpler to construct, prepare, consider, and deploy deep
studying fashions.

Set up

To put in Keras 3:

install.packages("keras3")
library(keras3)
install_keras()

Keras 3 comes with a full refresh of the website:
https://keras.posit.co. There, you’ll discover guides, tutorials,
reference pages with rendered examples, and a brand new examples gallery. All
the reference pages and guides are additionally out there through R’s built-in assist
system.

In a fast-paced ecosystem like deep studying, creating nice
documentation and wrappers as soon as isn’t sufficient. There additionally should be
workflows that make sure the documentation is up-to-date with upstream
dependencies. To perform this, {keras3} consists of two new maintainer
options that make sure the R documentation and performance wrappers will keep
up-to-date:

• We now take snapshots of the upstream documentation and API floor.
  With every launch, all R documentation is rebased on upstream
  updates. This workflow ensures that every one R documentation (guides,
  examples, vignettes, and reference pages) and R perform signatures
  keep up-to-date with upstream. This snapshot-and-rebase
  performance is carried out in a brand new standalone R bundle,
  {doctether}, which can
  be helpful for R bundle maintainers needing to maintain documentation in
  parity with dependencies.

• All examples and vignettes can now be evaluated and rendered throughout
  a bundle construct. This ensures that no stale or damaged instance code
  makes it right into a launch. It additionally means all consumer going through instance code
  now moreover serves as an prolonged suite of snapshot unit and
  integration checks.

  Evaluating code in vignettes and examples continues to be not permitted
  in keeping with CRAN restrictions. We work across the CRAN restriction
  by including extra bundle construct steps that pre-render
  examples
  and
  vignettes.

Mixed, these two options will make it considerably simpler for Keras
in R to keep up characteristic parity and up-to-date documentation with the
Python API to Keras.

Multi-backend assist

Quickly after its launch in 2015, Keras featured assist for hottest
deep studying frameworks: TensorFlow, Theano, MXNet, and CNTK. Over
time, the panorama shifted; Theano, MXNet, and CNTK have been retired, and
TensorFlow surged in reputation. In 2021, three years in the past, TensorFlow
grew to become the premier and solely supported Keras backend. Now, the panorama
has shifted once more.

Keras 3 brings the return of multi-backend assist. Select a backend by
calling:

use_backend("jax") # or "tensorflow", "torch", "numpy"

{keras3} introduces a new “Operations” family of function. The Ops
family, currently with over 200
functions,
gives a complete suite of operations usually wanted when
working on nd-arrays for deep studying. The Operation household
supersedes and significantly expands on the previous household of backend features
prefixed with k_ within the {keras} bundle.

The Ops features allow you to write backend-agnostic code. They supply a
uniform API, no matter in case you’re working with TensorFlow Tensors,
Jax Arrays, Torch Tensors, Keras Symbolic Tensors, NumPy arrays, or R
arrays.

The Ops features:

• all begin with prefix op_ (e.g., op_stack())
• all are pure features (they produce no side-effects)
• all use constant 1-based indexing, and coerce doubles to integers
  as wanted
• all are secure to make use of with any backend (tensorflow, jax, torch, numpy)
• all are secure to make use of in each keen and graph/jit/tracing modes

The Ops API consists of:

• The whole thing of the NumPy API (numpy.*)
• The TensorFlow NN API (tf.nn.*)
• Frequent linear algebra features (A subset of scipy.linalg.*)
• A subfamily of picture transformers
• A complete set of loss features
• And extra!

Ingest tabular information with layer_feature_space()

keras3 gives a brand new set of features for constructing fashions that ingest
tabular information: layer_feature_space() and a household of characteristic
transformer features (prefix, feature_) for constructing keras fashions
that may work with tabular information, both as inputs to a keras mannequin, or
as preprocessing steps in a knowledge loading pipeline (e.g., a
tfdatasets::dataset_map()).

See the reference
page and an
instance utilization in a full end-to-end
example
to be taught extra.

New Subclassing API

The subclassing API has been refined and prolonged to more Keras
types.
Outline subclasses just by calling: Layer(), Loss(), Metric(),
Callback(), Constraint(), Mannequin(), and LearningRateSchedule().
Defining {R6} proxy courses is not mandatory.

Moreover the documentation web page for every of the subclassing
features now comprises a complete itemizing of all of the out there
attributes and strategies for that sort. Take a look at
?Layer to see what’s
potential.

Saving and Export

Keras 3 brings a brand new mannequin serialization and export API. It’s now a lot
easier to avoid wasting and restore fashions, and likewise, to export them for
serving.

• save_model()/load_model():
  A brand new high-level file format (extension: .keras) for saving and
  restoring a full mannequin.

  The file format is backend-agnostic. This implies you could convert
  educated fashions between backends, just by saving with one backend,
  after which loading with one other. For instance, prepare a mannequin utilizing Jax,
  after which convert to Tensorflow for export.

• export_savedmodel():
  Export simply the ahead move of a mannequin as a compiled artifact for
  inference with TF
  Serving or (quickly)
  Posit Connect. This
  is the simplest method to deploy a Keras mannequin for environment friendly and
  concurrent inference serving, all with none R or Python runtime
  dependency.

• Decrease degree entry factors:

  • save_model_weights() / load_model_weights():
    save simply the weights as .h5 recordsdata.
  • save_model_config() / load_model_config():
    save simply the mannequin structure as a json file.

• register_keras_serializable():
  Register customized objects to allow them to be serialized and
  deserialized.

• serialize_keras_object() / deserialize_keras_object():
  Convert any Keras object to an R record of straightforward varieties that’s secure
  to transform to JSON or rds.

• See the brand new Serialization and Saving
  vignette
  for extra particulars and examples.

New random household

A brand new household of random tensor
generators.
Just like the Ops household, these work with all backends. Moreover, all of the
RNG-using strategies have assist for stateless utilization while you move in a
seed generator. This permits tracing and compilation by frameworks that
have particular assist for stateless, pure, features, like Jax. See
?random_seed_generator()
for instance utilization.

Different additions:

• New shape()
  perform, one-stop utility for working with tensor shapes in all
  contexts.

• New and improved print(mannequin) and plot(mannequin) technique. See some
  examples of output within the Functional API
  guide

• All new match() progress bar and reside metrics viewer output,
  together with new dark-mode assist within the RStudio IDE.

• New config
  family,
  a curated set of features for getting and setting Keras world
  configurations.

• All the different perform households have expanded with new members:

Migrating from {keras} to {keras3}

{keras3} is finally a preview of the long run {keras} bundle.

Should you’re writing new code in the present day, you can begin utilizing {keras3} proper
away.

When you have legacy code that makes use of {keras}, you might be inspired to
replace the code for {keras3}. For a lot of high-level API features, such
as layer_dense(), match(), and keras_model(), minimal to no modifications
are required. Nonetheless there’s a lengthy tail of small modifications that you just
would possibly have to make when updating code that made use of the lower-level
Keras API. A few of these are documented right here:
https://keras.io/guides/migrating_to_keras_3/.

Should you’re operating into points or have questions on updating, don’t
hesitate to ask on https://github.com/rstudio/keras/issues or
https://github.com/rstudio/keras/discussions.

The {keras} and {keras3} packages will coexist whereas the neighborhood
transitions. Throughout the transition, {keras} will proceed to obtain
patch updates for compatibility with Keras v2, which continues to be
printed to PyPi beneath the bundle title tf-keras.

{keras3} is meant as a transition bundle title. In a future replace,
the {keras} bundle will start emitting a bundle startup message,
asserting a deprecation interval. After a discover interval within the {keras}
bundle, {keras3} will probably be renamed to {keras}. At the moment {keras}
(v2) will not be supported, and {keras3} will probably be an alias for
{keras}.

Abstract

In abstract, {keras3} is a strong replace to the Keras R bundle,
incorporating new options whereas preserving the convenience of use and
performance of the unique. The brand new multi-backend assist,
complete suite of Ops features, refined mannequin serialization API,
and up to date documentation workflows allow customers to simply take
benefit of the newest developments within the deep studying neighborhood.

Whether or not you’re a seasoned Keras consumer or simply beginning your deep
studying journey, Keras 3 gives the instruments and suppleness to construct,
prepare, and deploy fashions with ease and confidence. As we transition from
Keras 2 to Keras 3, we’re dedicated to supporting the neighborhood and
guaranteeing a easy migration. We invite you to discover the brand new options,
take a look at the up to date documentation, and be part of the dialog on our
GitHub discussions web page. Welcome to the subsequent chapter of deep studying in
R with Keras 3!