Add files using upload-large-folder tool

testbed/google-deepmind__optax/.gitignore

@@ -0,0 +1,26 @@
+# Building and releasing library:
+*.egg-info
+*.pyc
+*.so
+build/
+dist/
+venv/
+_testing/
+
+# Building the documentation
+docs/_autosummary
+docs/_collections
+docs/modules/generated
+
+# Mac OS
+.DS_Store
+
+# Python tools
+.mypy_cache/
+.pytype/
+.ipynb_checkpoints
+
+# Editors
+.idea
+.vscode
+

testbed/google-deepmind__optax/CONTRIBUTING.md

@@ -0,0 +1,34 @@
+# How to Contribute
+
+We'd love to accept your patches and contributions to this project. There are
+just a few small guidelines you need to follow.
+
+## Contributor License Agreement
+
+Contributions to this project must be accompanied by a Contributor License
+Agreement. You (or your employer) retain the copyright to your contribution;
+this simply gives us permission to use and redistribute your contributions as
+part of the project. Head over to <https://cla.developers.google.com/> to see
+your current agreements on file or to sign a new one.
+
+You generally only need to submit a CLA once, so if you've already submitted one
+(even if it was for a different project), you probably don't need to do it
+again.
+
+## Code reviews
+
+All submissions, including submissions by project members, require review. We
+use GitHub pull requests for this purpose. Consult
+[GitHub Help](https://help.github.com/articles/about-pull-requests/) for more
+information on using pull requests.
+
+## Testing
+
+Please make sure that your PR passes all tests by running `bash test.sh` on your
+local machine. Also, you can run only tests that are affected by your code
+changes, but you will need to select them manually.
+
+## Community Guidelines
+
+This project follows [Google's Open Source Community
+Guidelines](https://opensource.google.com/conduct/).

testbed/google-deepmind__optax/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

testbed/google-deepmind__optax/README.md

@@ -0,0 +1,144 @@
+# Optax
+
+![CI status](https://github.com/google-deepmind/optax/actions/workflows/tests.yml/badge.svg?branch=main)
+[![Documentation Status](https://readthedocs.org/projects/optax/badge/?version=latest)](http://optax.readthedocs.io)
+![pypi](https://img.shields.io/pypi/v/optax)
+
+## Introduction
+
+Optax is a gradient processing and optimization library for JAX.
+
+Optax is designed to facilitate research by providing building blocks
+that can be easily recombined in custom ways.
+
+Our goals are to
+
+*   Provide simple, well-tested, efficient implementations of core components.
+*   Improve research productivity by enabling to easily combine low-level
+    ingredients into custom optimisers (or other gradient processing components).
+*   Accelerate adoption of new ideas by making it easy for anyone to contribute.
+
+We favour focusing on small composable building blocks that can be effectively
+combined into custom solutions. Others may build upon these basic components
+in more complicated abstractions. Whenever reasonable, implementations prioritise
+readability and structuring code to match standard equations, over code reuse.
+
+An initial prototype of this library was made available in JAX's experimental
+folder as `jax.experimental.optix`. Given the wide adoption across DeepMind
+of `optix`, and after a few iterations on the API, `optix` was eventually moved
+out of `experimental` as a standalone open-source library, and renamed `optax`.
+
+Documentation on Optax can be found at [optax.readthedocs.io](https://optax.readthedocs.io/).
+
+## Installation
+
+You can install the latest released version of Optax from PyPI via:
+
+```sh
+pip install optax
+```
+
+or you can install the latest development version from GitHub:
+
+```sh
+pip install git+https://github.com/google-deepmind/optax.git
+```
+
+## Quickstart
+
+Optax contains implementations of [many popular optimizers](https://optax.readthedocs.io/en/latest/api/optimizers.html) and
+[loss functions](https://optax.readthedocs.io/en/latest/api/losses.html).
+For example, the following code snippet uses the Adam optimizer from `optax.adam`
+and the mean squared error from `optax.l2_loss`. We initialize the optimizer
+state using the `init` function and `params` of the model.
+
+```python
+optimizer = optax.adam(learning_rate)
+# Obtain the `opt_state` that contains statistics for the optimizer.
+params = {'w': jnp.ones((num_weights,))}
+opt_state = optimizer.init(params)
+```
+
+To write the update loop we need a loss function that can be differentiated by
+Jax (with `jax.grad` in this
+example) to obtain the gradients.
+
+```python
+compute_loss = lambda params, x, y: optax.l2_loss(params['w'].dot(x), y)
+grads = jax.grad(compute_loss)(params, xs, ys)
+```
+
+The gradients are then converted via `optimizer.update` to obtain the updates
+that should be applied to the current parameters to obtain the new ones.
+`optax.apply_updates` is a convenience utility to do this.
+
+```python
+updates, opt_state = optimizer.update(grads, opt_state)
+params = optax.apply_updates(params, updates)
+```
+
+You can continue the quick start in [the Optax 🚀 Getting started notebook.](https://github.com/google-deepmind/optax/blob/main/docs/getting_started.ipynb)
+
+## Development
+
+We welcome new contributors.
+
+### Source code
+
+You can check the latest sources with the following command.
+
+```sh
+git clone https://github.com/google-deepmind/optax.git
+```
+### Testing
+
+To run the tests, please execute the following script.
+
+```sh
+sh ./test.sh
+```
+
+### Documentation
+
+To build the documentation, first ensure that all the dependencies are installed.
+```sh
+pip install -e ".[docs]"
+```
+Then, execute the following.
+```sh
+cd docs/
+make html
+```
+
+## Benchmarks
+If you feel lost in the crowd of available optimizers for deep learning, there
+exist some extensive benchmarks:
+
+[Benchmarking Neural Network Training Algorithms, Dahl G. et al, 2023](https://arxiv.org/pdf/2306.07179),
+
+[Descending through a Crowded Valley — Benchmarking Deep Learning Optimizers, Schmidt R. et al, 2021](https://proceedings.mlr.press/v139/schmidt21a).
+
+If you are interested in developing your own benchmark for some tasks,
+consider the following framework
+
+[Benchopt: Reproducible, efficient and collaborative optimization benchmarks, Moreau T. et al, 2022](https://arxiv.org/abs/2206.13424).
+
+Finally, if you are searching for some recommendations on tuning optimizers,
+consider taking a look at
+
+[Deep Learning Tuning Playbook, Godbole V. et al, 2023](https://github.com/google-research/tuning_playbook).
+
+
+## Citing Optax
+
+This repository is part of the DeepMind JAX Ecosystem, to cite Optax
+please use the citation:
+
+```bibtex
+@software{deepmind2020jax,
+  title = {The {D}eep{M}ind {JAX} {E}cosystem},
+  author = {DeepMind and Babuschkin, Igor and Baumli, Kate and Bell, Alison and Bhupatiraju, Surya and Bruce, Jake and Buchlovsky, Peter and Budden, David and Cai, Trevor and Clark, Aidan and Danihelka, Ivo and Dedieu, Antoine and Fantacci, Claudio and Godwin, Jonathan and Jones, Chris and Hemsley, Ross and Hennigan, Tom and Hessel, Matteo and Hou, Shaobo and Kapturowski, Steven and Keck, Thomas and Kemaev, Iurii and King, Michael and Kunesch, Markus and Martens, Lena and Merzic, Hamza and Mikulik, Vladimir and Norman, Tamara and Papamakarios, George and Quan, John and Ring, Roman and Ruiz, Francisco and Sanchez, Alvaro and Sartran, Laurent and Schneider, Rosalia and Sezener, Eren and Spencer, Stephen and Srinivasan, Srivatsan and Stanojevi\'{c}, Milo\v{s} and Stokowiec, Wojciech and Wang, Luyu and Zhou, Guangyao and Viola, Fabio},
+  url = {http://github.com/google-deepmind},
+  year = {2020},
+}
+```

testbed/google-deepmind__optax/optax/__init__.py

@@ -0,0 +1,459 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Optax: composable gradient processing and optimization, in JAX."""
+
+# pylint: disable=wrong-import-position
+# pylint: disable=g-importing-member
+
+from optax import contrib
+from optax import losses
+from optax import monte_carlo
+from optax import projections
+from optax import schedules
+from optax import second_order
+from optax import transforms
+from optax import tree_utils
+from optax._src.alias import adabelief
+from optax._src.alias import adadelta
+from optax._src.alias import adafactor
+from optax._src.alias import adagrad
+from optax._src.alias import adam
+from optax._src.alias import adamax
+from optax._src.alias import adamaxw
+from optax._src.alias import adamw
+from optax._src.alias import amsgrad
+from optax._src.alias import fromage
+from optax._src.alias import lamb
+from optax._src.alias import lars
+from optax._src.alias import lion
+from optax._src.alias import MaskOrFn
+from optax._src.alias import nadam
+from optax._src.alias import nadamw
+from optax._src.alias import noisy_sgd
+from optax._src.alias import novograd
+from optax._src.alias import optimistic_gradient_descent
+from optax._src.alias import polyak_sgd
+from optax._src.alias import radam
+from optax._src.alias import rmsprop
+from optax._src.alias import rprop
+from optax._src.alias import sgd
+from optax._src.alias import sm3
+from optax._src.alias import yogi
+from optax._src.base import EmptyState
+from optax._src.base import GradientTransformation
+from optax._src.base import GradientTransformationExtraArgs
+from optax._src.base import identity
+from optax._src.base import OptState
+from optax._src.base import Params
+from optax._src.base import ScalarOrSchedule
+from optax._src.base import Schedule
+from optax._src.base import set_to_zero
+from optax._src.base import stateless
+from optax._src.base import stateless_with_tree_map
+from optax._src.base import TransformInitFn
+from optax._src.base import TransformUpdateExtraArgsFn
+from optax._src.base import TransformUpdateFn
+from optax._src.base import Updates
+from optax._src.base import with_extra_args_support
+from optax._src.clipping import adaptive_grad_clip
+from optax._src.clipping import AdaptiveGradClipState
+from optax._src.clipping import clip
+from optax._src.clipping import clip_by_block_rms
+from optax._src.clipping import clip_by_global_norm
+from optax._src.clipping import ClipByGlobalNormState
+from optax._src.clipping import ClipState
+from optax._src.clipping import per_example_global_norm_clip
+from optax._src.clipping import per_example_layer_norm_clip
+from optax._src.combine import chain
+from optax._src.combine import multi_transform
+from optax._src.combine import MultiTransformState
+from optax._src.combine import named_chain
+from optax._src.constrain import keep_params_nonnegative
+from optax._src.constrain import NonNegativeParamsState
+from optax._src.constrain import zero_nans
+from optax._src.constrain import ZeroNansState
+from optax._src.factorized import FactoredState
+from optax._src.factorized import scale_by_factored_rms
+from optax._src.linear_algebra import global_norm
+from optax._src.linear_algebra import matrix_inverse_pth_root
+from optax._src.linear_algebra import power_iteration
+from optax._src.linesearch import scale_by_backtracking_linesearch
+from optax._src.linesearch import ScaleByBacktrackingLinesearchState
+from optax._src.lookahead import lookahead
+from optax._src.lookahead import LookaheadParams
+from optax._src.lookahead import LookaheadState
+from optax._src.numerics import safe_int32_increment
+from optax._src.numerics import safe_norm
+from optax._src.numerics import safe_root_mean_squares
+from optax._src.transform import add_decayed_weights
+from optax._src.transform import add_noise
+from optax._src.transform import AddDecayedWeightsState
+from optax._src.transform import AddNoiseState
+from optax._src.transform import apply_every
+from optax._src.transform import ApplyEvery
+from optax._src.transform import centralize
+from optax._src.transform import ema
+from optax._src.transform import EmaState
+from optax._src.transform import scale
+from optax._src.transform import scale_by_adadelta
+from optax._src.transform import scale_by_adam
+from optax._src.transform import scale_by_adamax
+from optax._src.transform import scale_by_amsgrad
+from optax._src.transform import scale_by_belief
+from optax._src.transform import scale_by_distance_over_gradients
+from optax._src.transform import scale_by_learning_rate
+from optax._src.transform import scale_by_lion
+from optax._src.transform import scale_by_novograd
+from optax._src.transform import scale_by_optimistic_gradient
+from optax._src.transform import scale_by_param_block_norm
+from optax._src.transform import scale_by_param_block_rms
+from optax._src.transform import scale_by_polyak
+from optax._src.transform import scale_by_radam
+from optax._src.transform import scale_by_rms
+from optax._src.transform import scale_by_rprop
+from optax._src.transform import scale_by_rss
+from optax._src.transform import scale_by_schedule
+from optax._src.transform import scale_by_sm3
+from optax._src.transform import scale_by_stddev
+from optax._src.transform import scale_by_trust_ratio
+from optax._src.transform import scale_by_yogi
+from optax._src.transform import ScaleByAdaDeltaState
+from optax._src.transform import ScaleByAdamState
+from optax._src.transform import ScaleByAmsgradState
+from optax._src.transform import ScaleByBeliefState
+from optax._src.transform import ScaleByLionState
+from optax._src.transform import ScaleByNovogradState
+from optax._src.transform import ScaleByRmsState
+from optax._src.transform import ScaleByRpropState
+from optax._src.transform import ScaleByRssState
+from optax._src.transform import ScaleByRStdDevState
+from optax._src.transform import ScaleByScheduleState
+from optax._src.transform import ScaleBySM3State
+from optax._src.transform import ScaleByTrustRatioState
+from optax._src.transform import ScaleState
+from optax._src.transform import trace
+from optax._src.transform import TraceState
+from optax._src.update import apply_updates
+from optax._src.update import incremental_update
+from optax._src.update import periodic_update
+from optax._src.utils import multi_normal
+from optax._src.utils import scale_gradient
+from optax._src.utils import value_and_grad_from_state
+from optax._src.wrappers import apply_if_finite
+from optax._src.wrappers import ApplyIfFiniteState
+from optax._src.wrappers import conditionally_mask
+from optax._src.wrappers import conditionally_transform
+from optax._src.wrappers import ConditionallyMaskState
+from optax._src.wrappers import ConditionallyTransformState
+from optax._src.wrappers import flatten
+from optax._src.wrappers import masked
+from optax._src.wrappers import MaskedNode
+from optax._src.wrappers import MaskedState
+from optax._src.wrappers import maybe_update
+from optax._src.wrappers import MaybeUpdateState
+from optax._src.wrappers import MultiSteps
+from optax._src.wrappers import MultiStepsState
+from optax._src.wrappers import ShouldSkipUpdateFunction
+from optax._src.wrappers import skip_large_updates
+from optax._src.wrappers import skip_not_finite
+
+
+# TODO(mtthss): remove tree_utils aliases after updates.
+tree_map_params = tree_utils.tree_map_params
+bias_correction = tree_utils.tree_bias_correction
+update_infinity_moment = tree_utils.tree_update_infinity_moment
+update_moment = tree_utils.tree_update_moment
+update_moment_per_elem_norm = tree_utils.tree_update_moment_per_elem_norm
+
+# TODO(mtthss): remove schedules alises from flat namespaces after user updates.
+constant_schedule = schedules.constant_schedule
+cosine_decay_schedule = schedules.cosine_decay_schedule
+cosine_onecycle_schedule = schedules.cosine_onecycle_schedule
+exponential_decay = schedules.exponential_decay
+inject_hyperparams = schedules.inject_hyperparams
+InjectHyperparamsState = schedules.InjectHyperparamsState
+join_schedules = schedules.join_schedules
+linear_onecycle_schedule = schedules.linear_onecycle_schedule
+linear_schedule = schedules.linear_schedule
+piecewise_constant_schedule = schedules.piecewise_constant_schedule
+piecewise_interpolate_schedule = schedules.piecewise_interpolate_schedule
+polynomial_schedule = schedules.polynomial_schedule
+sgdr_schedule = schedules.sgdr_schedule
+warmup_cosine_decay_schedule = schedules.warmup_cosine_decay_schedule
+warmup_exponential_decay_schedule = schedules.warmup_exponential_decay_schedule
+inject_stateful_hyperparams = schedules.inject_stateful_hyperparams
+InjectStatefulHyperparamsState = schedules.InjectStatefulHyperparamsState
+WrappedSchedule = schedules.WrappedSchedule
+
+# TODO(mtthss): remove loss aliases from flat namespace once users have updated.
+convex_kl_divergence = losses.convex_kl_divergence
+cosine_distance = losses.cosine_distance
+cosine_similarity = losses.cosine_similarity
+ctc_loss = losses.ctc_loss
+ctc_loss_with_forward_probs = losses.ctc_loss_with_forward_probs
+hinge_loss = losses.hinge_loss
+huber_loss = losses.huber_loss
+kl_divergence = losses.kl_divergence
+l2_loss = losses.l2_loss
+log_cosh = losses.log_cosh
+ntxent = losses.ntxent
+sigmoid_binary_cross_entropy = losses.sigmoid_binary_cross_entropy
+smooth_labels = losses.smooth_labels
+safe_softmax_cross_entropy = losses.safe_softmax_cross_entropy
+softmax_cross_entropy = losses.softmax_cross_entropy
+softmax_cross_entropy_with_integer_labels = (
+    losses.softmax_cross_entropy_with_integer_labels
+)
+squared_error = losses.squared_error
+sigmoid_focal_loss = losses.sigmoid_focal_loss
+
+# pylint: disable=g-import-not-at-top
+# TODO(mtthss): remove contrib aliases from flat namespace once users updated.
+# Deprecated modules
+from optax.contrib import differentially_private_aggregate as _deprecated_differentially_private_aggregate
+from optax.contrib import DifferentiallyPrivateAggregateState as _deprecated_DifferentiallyPrivateAggregateState
+from optax.contrib import dpsgd as _deprecated_dpsgd
+
+_deprecations = {
+    # Added Apr 2024
+    "differentially_private_aggregate": (
+        (
+            "optax.differentially_private_aggregate is deprecated: use"
+            " optax.contrib.differentially_private_aggregate (optax v0.1.8 or"
+            " newer)."
+        ),
+        _deprecated_differentially_private_aggregate,
+    ),
+    "DifferentiallyPrivateAggregateState": (
+        (
+            "optax.DifferentiallyPrivateAggregateState is deprecated: use"
+            " optax.contrib.DifferentiallyPrivateAggregateState (optax v0.1.8"
+            " or newer)."
+        ),
+        _deprecated_DifferentiallyPrivateAggregateState,
+    ),
+    "dpsgd": (
+        (
+            "optax.dpsgd is deprecated: use optax.contrib.dpsgd (optax v0.1.8"
+            " or newer)."
+        ),
+        _deprecated_dpsgd,
+    ),
+}
+# pylint: disable=g-bad-import-order
+import typing as _typing
+
+if _typing.TYPE_CHECKING:
+  # pylint: disable=reimported
+  from optax.contrib import differentially_private_aggregate
+  from optax.contrib import DifferentiallyPrivateAggregateState
+  from optax.contrib import dpsgd
+  # pylint: enable=reimported
+
+else:
+  from optax._src.deprecations import deprecation_getattr as _deprecation_getattr
+
+  __getattr__ = _deprecation_getattr(__name__, _deprecations)
+  del _deprecation_getattr
+del _typing
+# pylint: enable=g-bad-import-order
+# pylint: enable=g-import-not-at-top
+# pylint: enable=g-importing-member
+
+
+__version__ = "0.2.3.dev"
+
+__all__ = (
+    "adabelief",
+    "adadelta",
+    "adafactor",
+    "adagrad",
+    "adam",
+    "adamax",
+    "adamaxw",
+    "adamw",
+    "adaptive_grad_clip",
+    "AdaptiveGradClipState",
+    "add_decayed_weights",
+    "add_noise",
+    "AddDecayedWeightsState",
+    "AddNoiseState",
+    "amsgrad",
+    "apply_every",
+    "apply_if_finite",
+    "apply_updates",
+    "ApplyEvery",
+    "ApplyIfFiniteState",
+    "centralize",
+    "chain",
+    "clip_by_block_rms",
+    "clip_by_global_norm",
+    "clip",
+    "ClipByGlobalNormState",
+    "ClipState",
+    "conditionally_mask",
+    "ConditionallyMaskState",
+    "conditionally_transform",
+    "ConditionallyTransformState",
+    "constant_schedule",
+    "ctc_loss",
+    "ctc_loss_with_forward_probs",
+    "convex_kl_divergence",
+    "cosine_decay_schedule",
+    "cosine_distance",
+    "cosine_onecycle_schedule",
+    "cosine_similarity",
+    "differentially_private_aggregate",
+    "DifferentiallyPrivateAggregateState",
+    "dpsgd",
+    "ema",
+    "EmaState",
+    "EmptyState",
+    "exponential_decay",
+    "FactoredState",
+    "flatten",
+    "fromage",
+    "global_norm",
+    "GradientTransformation",
+    "GradientTransformationExtraArgs",
+    "hinge_loss",
+    "huber_loss",
+    "identity",
+    "incremental_update",
+    "inject_hyperparams",
+    "InjectHyperparamsState",
+    "join_schedules",
+    "keep_params_nonnegative",
+    "kl_divergence",
+    "l2_loss",
+    "lamb",
+    "lars",
+    "lion",
+    "linear_onecycle_schedule",
+    "linear_schedule",
+    "log_cosh",
+    "lookahead",
+    "LookaheadParams",
+    "LookaheadState",
+    "masked",
+    "MaskOrFn",
+    "MaskedState",
+    "matrix_inverse_pth_root",
+    "maybe_update",
+    "MaybeUpdateState",
+    "multi_normal",
+    "multi_transform",
+    "MultiSteps",
+    "MultiStepsState",
+    "MultiTransformState",
+    "nadam",
+    "nadamw",
+    "noisy_sgd",
+    "novograd",
+    "NonNegativeParamsState",
+    "ntxent",
+    "OptState",
+    "Params",
+    "periodic_update",
+    "per_example_global_norm_clip",
+    "per_example_layer_norm_clip",
+    "piecewise_constant_schedule",
+    "piecewise_interpolate_schedule",
+    "polynomial_schedule",
+    "power_iteration",
+    "polyak_sgd",
+    "radam",
+    "rmsprop",
+    "rprop",
+    "safe_int32_increment",
+    "safe_norm",
+    "safe_root_mean_squares",
+    "ScalarOrSchedule",
+    "scale_by_adadelta",
+    "scale_by_adam",
+    "scale_by_adamax",
+    "scale_by_amsgrad",
+    "scale_by_backtracking_linesearch",
+    "scale_by_belief",
+    "scale_by_lion",
+    "scale_by_factored_rms",
+    "scale_by_novograd",
+    "scale_by_param_block_norm",
+    "scale_by_param_block_rms",
+    "scale_by_polyak",
+    "scale_by_radam",
+    "scale_by_rms",
+    "scale_by_rprop",
+    "scale_by_rss",
+    "scale_by_schedule",
+    "scale_by_sm3",
+    "scale_by_stddev",
+    "scale_by_trust_ratio",
+    "scale_by_yogi",
+    "scale_gradient",
+    "scale",
+    "ScaleByAdaDeltaState",
+    "ScaleByAdamState",
+    "ScaleByAmsgradState",
+    "ScaleByBacktrackingLinesearchState",
+    "ScaleByBeliefState",
+    "ScaleByLionState",
+    "ScaleByNovogradState",
+    "ScaleByRmsState",
+    "ScaleByRpropState",
+    "ScaleByRssState",
+    "ScaleByRStdDevState",
+    "ScaleByScheduleState",
+    "ScaleBySM3State",
+    "ScaleByTrustRatioState",
+    "ScaleState",
+    "Schedule",
+    "set_to_zero",
+    "sgd",
+    "sgdr_schedule",
+    "ShouldSkipUpdateFunction",
+    "sigmoid_binary_cross_entropy",
+    "skip_large_updates",
+    "skip_not_finite",
+    "sm3",
+    "smooth_labels",
+    "softmax_cross_entropy",
+    "softmax_cross_entropy_with_integer_labels",
+    "stateless",
+    "stateless_with_tree_map",
+    "trace",
+    "TraceState",
+    "TransformInitFn",
+    "TransformUpdateFn",
+    "TransformUpdateExtraArgsFn",
+    "Updates",
+    "value_and_grad_from_state",
+    "warmup_cosine_decay_schedule",
+    "warmup_exponential_decay_schedule",
+    "yogi",
+    "zero_nans",
+    "ZeroNansState",
+)
+
+#  _________________________________________
+# / Please don't use symbols in `_src` they \
+# \ are not part of the Optax public API.   /
+#  -----------------------------------------
+#         \   ^__^
+#          \  (oo)\_______
+#             (__)\       )\/\
+#                 ||----w |
+#                 ||     ||
+#

testbed/google-deepmind__optax/optax/losses/_classification.py

@@ -0,0 +1,681 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Classification losses."""
+
+import functools
+from typing import Optional
+
+import chex
+import jax
+import jax.numpy as jnp
+
+
+def sigmoid_binary_cross_entropy(
+    logits,
+    labels,
+):
+  """Computes element-wise sigmoid cross entropy given logits and labels.
+
+  This function can be used for binary or multiclass classification (where each
+  class is an independent binary prediction and different classes are not
+  mutually exclusive e.g. predicting that an image contains both a cat
+  and a dog.)
+
+  Because this function is overloaded, please ensure your `logits` and `labels`
+  are compatible with each other. If you're passing in binary `labels` (values
+  in {0, 1}), ensure your `logits` correspond to class 1 only. If you're
+  passing in per-class target probabilities or one-hot `labels`, please ensure
+  your `logits` are also multiclass. Be particularly careful if you're relying
+  on implicit broadcasting to reshape `logits` or `labels`.
+
+  References:
+    [Goodfellow et al, 2016](http://www.deeplearningbook.org/contents/prob.html)
+
+  Args:
+    logits: Each element is the unnormalized log probability of a binary
+      prediction. See note about compatibility with `labels` above.
+    labels: Binary labels whose values are {0,1} or multi-class target
+      probabilities. See note about compatibility with `logits` above.
+
+  Returns:
+    cross entropy for each binary prediction, same shape as `logits`.
+  """
+  chex.assert_type([logits], float)
+  labels = labels.astype(logits.dtype)
+  log_p = jax.nn.log_sigmoid(logits)
+  # log(1 - sigmoid(x)) = log_sigmoid(-x), the latter more numerically stable
+  log_not_p = jax.nn.log_sigmoid(-logits)
+  return -labels * log_p - (1. - labels) * log_not_p
+
+
+@functools.partial(
+    chex.warn_deprecated_function,
+    replacement='sigmoid_binary_cross_entropy')
+def binary_logistic_loss(logits, labels):
+  return sigmoid_binary_cross_entropy(logits, labels)
+
+
+def hinge_loss(
+    predictor_outputs: chex.Array,
+    targets: chex.Array
+) -> chex.Array:
+  """Computes the hinge loss for binary classification.
+
+  Args:
+    predictor_outputs: Outputs of the decision function.
+    targets: Target values. Target values should be strictly in the set {-1, 1}.
+
+  Returns:
+    loss value.
+  """
+  return jnp.maximum(0, 1 - predictor_outputs * targets)
+
+
+def perceptron_loss(
+    predictor_outputs: chex.Numeric,
+    targets: chex.Numeric
+) -> chex.Numeric:
+  """Binary perceptron loss.
+
+  References:
+    https://en.wikipedia.org/wiki/Perceptron
+
+  Args:
+    predictor_outputs: score produced by the model (float).
+    targets: Target values. Target values should be strictly in the set {-1, 1}.
+
+  Returns:
+    loss value.
+  """
+  chex.assert_equal_shape([predictor_outputs, targets])
+  return jnp.maximum(0, - predictor_outputs * targets)
+
+
+def sparsemax_loss(
+    logits: chex.Array,
+    labels: chex.Array,
+) -> chex.Array:
+  """Binary sparsemax loss.
+
+  This loss is zero if and only if `jax.nn.sparse_sigmoid(logits) == labels`.
+
+  References:
+    Learning with Fenchel-Young Losses. Mathieu Blondel, André F. T. Martins,
+    Vlad Niculae. JMLR 2020. (Sec. 4.4)
+
+  Args:
+    logits: score produced by the model (float).
+    labels: ground-truth integer label (0 or 1).
+
+  Returns:
+    loss value
+
+  .. versionadded:: 0.2.3
+  """
+  return jax.nn.sparse_plus(jnp.where(labels, -logits, logits))
+
+
+@functools.partial(
+    chex.warn_deprecated_function,
+    replacement='sparsemax_loss')
+def binary_sparsemax_loss(logits, labels):
+  return sparsemax_loss(logits, labels)
+
+
+@jax.custom_jvp
+def weighted_logsoftmax(x: chex.Array, weights: chex.Array) -> chex.Array:
+  r"""Weighted logsoftmax.
+
+  Computes
+  .. math::
+    (w_i \log(\exp x_i /(\sum_i \exp x_i )) )_{i=1}^n
+
+  for :math:`x` the input ``x``, :math:`w` the ``weights``.
+  For :math:`w_i = 0`, :math:`x_i=-\infty`, this implementation ensures that the
+  output is 0 and not nan at the ith entry following the convention that
+  :math:`0 \log 0 = 0`.
+
+  Args:
+    x: input array.
+    weights: weights.
+
+  Returns:
+    logsoftmax of x multiplied elementwise by weights
+  """
+  logsoftmax_x = jax.nn.log_softmax(x, axis=-1)
+  return jnp.where(
+      weights != 0.0, weights * logsoftmax_x, jnp.zeros_like(logsoftmax_x)
+  )
+
+
+def _weighted_logsoftmax_jvp(primals, tangents):
+  """Custom JVP of weighted logsoftmax."""
+  (x, weights) = primals
+  (x_dot, weights_dot) = tangents
+  logsoftmax_x = jax.nn.log_softmax(x, axis=-1)
+  result = jnp.where(
+      weights != 0.0, weights * logsoftmax_x, jnp.zeros_like(logsoftmax_x)
+  )
+  out_tangents = (
+      weights * x_dot
+      - weights
+      * jnp.sum(x_dot * jax.nn.softmax(x, axis=-1), axis=-1, keepdims=True)
+      + weights_dot * logsoftmax_x
+  )
+  return result, out_tangents
+
+
+weighted_logsoftmax.defjvp(_weighted_logsoftmax_jvp)
+
+
+def safe_softmax_cross_entropy(
+    logits: chex.Array,
+    labels: chex.Array,
+) -> chex.Array:
+  """Computes the softmax cross entropy between sets of logits and labels.
+
+  Contrarily to :func:`optax.softmax_cross_entropy` this function handles
+  ``labels*logsoftmax(logits)`` as ``0`` when ``logits=-inf`` and ``labels=0``,
+  following the convention that ``0 log 0 = 0``.
+
+  Args:
+    logits: Unnormalized log probabilities, with shape `[..., num_classes]`.
+    labels: Valid probability distributions (non-negative, sum to 1), e.g a
+      one hot encoding specifying the correct class for each input;
+      must have a shape broadcastable to `[..., num_classes]`.
+
+  Returns:
+    cross entropy between each prediction and the corresponding target
+    distributions, with shape `[...]`.
+  """
+  chex.assert_type([logits], float)
+  return -jnp.sum(weighted_logsoftmax(logits, labels), axis=-1)
+
+
+def softmax_cross_entropy(
+    logits: chex.Array,
+    labels: chex.Array,
+) -> chex.Array:
+  """Computes the softmax cross entropy between sets of logits and labels.
+
+  Measures the probability error in discrete classification tasks in which
+  the classes are mutually exclusive (each entry is in exactly one class).
+  For example, each CIFAR-10 image is labeled with one and only one label:
+  an image can be a dog or a truck, but not both.
+
+  References:
+    [Goodfellow et al, 2016](http://www.deeplearningbook.org/contents/prob.html)
+
+  Args:
+    logits: Unnormalized log probabilities, with shape `[..., num_classes]`.
+    labels: Valid probability distributions (non-negative, sum to 1), e.g a
+      one hot encoding specifying the correct class for each input;
+      must have a shape broadcastable to `[..., num_classes]`.
+
+  Returns:
+    cross entropy between each prediction and the corresponding target
+    distributions, with shape `[...]`.
+
+  .. seealso:: :func:`optax.safe_softmax_cross_entropy`
+  """
+  chex.assert_type([logits], float)
+  return -jnp.sum(labels * jax.nn.log_softmax(logits, axis=-1), axis=-1)
+
+
+def softmax_cross_entropy_with_integer_labels(
+    logits: chex.Array,
+    labels: chex.Array,
+) -> chex.Array:
+  """Computes softmax cross entropy between sets of logits and integer labels.
+
+  Measures the probability error in discrete classification tasks in which
+  the classes are mutually exclusive (each entry is in exactly one class).
+  For example, each CIFAR-10 image is labeled with one and only one label:
+  an image can be a dog or a truck, but not both.
+
+  References:
+    [Goodfellow et al, 2016](http://www.deeplearningbook.org/contents/prob.html)
+
+  Args:
+    logits: Unnormalized log probabilities, with shape `[..., num_classes]`.
+    labels: Integers specifying the correct class for each input, with shape
+      `[...]`.
+
+  Returns:
+    Cross entropy between each prediction and the corresponding target
+    distributions, with shape `[...]`.
+  """
+  chex.assert_type([logits], float)
+  chex.assert_type([labels], int)
+  # This is like jnp.take_along_axis(jax.nn.log_softmax(...), ...) except that
+  # we avoid subtracting the normalizer from all values, just from the values
+  # for the correct labels.
+  logits_max = jnp.max(logits, axis=-1, keepdims=True)
+  logits -= jax.lax.stop_gradient(logits_max)
+  label_logits = jnp.take_along_axis(logits, labels[..., None], axis=-1)[..., 0]
+  log_normalizers = jnp.log(jnp.sum(jnp.exp(logits), axis=-1))
+  return log_normalizers - label_logits
+
+
+@functools.partial(
+    chex.warn_deprecated_function,
+    replacement='softmax_cross_entropy_with_integer_labels')
+def multiclass_logistic_loss(logits, labels):
+  return softmax_cross_entropy_with_integer_labels(logits, labels)
+
+
+_dot_last_dim = jnp.vectorize(jnp.dot, signature='(n),(n)->()')
+
+
+def multiclass_hinge_loss(
+    scores: chex.Array,
+    labels: chex.Array,
+) -> chex.Array:
+  """Multiclass hinge loss.
+
+  References:
+    https://en.wikipedia.org/wiki/Hinge_loss
+
+  Args:
+    scores: scores produced by the model (floats).
+    labels: ground-truth integer labels.
+
+  Returns:
+    loss values
+
+  .. versionadded:: 0.2.3
+  """
+  one_hot_labels = jax.nn.one_hot(labels, scores.shape[-1])
+  return (jnp.max(scores + 1.0 - one_hot_labels, axis=-1) -
+          _dot_last_dim(scores, one_hot_labels))
+
+
+def multiclass_perceptron_loss(
+    scores: chex.Array,
+    labels: chex.Array,
+) -> chex.Array:
+  """Multiclass perceptron loss.
+
+  References:
+    Michael Collins. Discriminative training methods for Hidden Markov Models:
+    Theory and experiments with perceptron algorithms. EMNLP 2002
+
+  Args:
+    scores: scores produced by the model.
+    labels: ground-truth integer labels.
+
+  Returns:
+    loss values.
+
+  .. versionadded:: 0.2.2
+  """
+  one_hot_labels = jax.nn.one_hot(labels, scores.shape[-1])
+  return jnp.max(scores, axis=-1) - _dot_last_dim(scores, one_hot_labels)
+
+
+@functools.partial(chex.warn_only_n_pos_args_in_future, n=2)
+def poly_loss_cross_entropy(
+    logits: chex.Array,
+    labels: chex.Array,
+    epsilon: float = 2.0
+) -> chex.Array:
+  r"""Computes PolyLoss between logits and labels.
+
+  The PolyLoss is a loss function that decomposes commonly
+  used classification loss functions into a series of weighted
+  polynomial bases. It is inspired by the Taylor expansion of
+  cross-entropy loss and focal loss in the bases of :math:`(1 − P_t)^j`.
+
+  .. math::
+    L_{Poly} = \sum_1^\infty \alpha_j \cdot (1 - P_t)^j \\
+    L_{Poly-N} = (\epsilon_1 + 1) \cdot (1 - P_t) + \ldots + \\
+    (\epsilon_N + \frac{1}{N}) \cdot (1 - P_t)^N +
+    \frac{1}{N + 1} \cdot (1 - P_t)^{N + 1} + \ldots = \\
+    - \log(P_t) + \sum_{j = 1}^N \epsilon_j \cdot (1 - P_t)^j
+
+  This function provides a simplified version of :math:`L_{Poly-N}`
+  with only the coefficient of the first polynomial term being changed.
+
+  References:
+    [Zhaoqi Leng et al, 2022](https://arxiv.org/pdf/2204.12511.pdf)
+
+  Args:
+    logits: Unnormalized log probabilities, with shape `[..., num_classes]`.
+    labels: Valid probability distributions (non-negative, sum to 1), e.g. a
+      one hot encoding specifying the correct class for each input;
+      must have a shape broadcastable to `[..., num_classes]`.
+    epsilon: The coefficient of the first polynomial term.
+      According to the paper, the following values are recommended:
+      - For the ImageNet 2d image classification, epsilon = 2.0.
+      - For the 2d Instance Segmentation and object detection, epsilon = -1.0.
+      - It is also recommended to adjust this value based on the task, e.g. by
+        using grid search.
+
+  Returns:
+    Poly loss between each prediction and the corresponding target
+    distributions, with shape `[...]`.
+  """
+  chex.assert_type([logits, labels], float)
+  one_minus_pt = jnp.sum(labels * (1 - jax.nn.softmax(logits)), axis=-1)
+  cross_entropy = softmax_cross_entropy(logits=logits, labels=labels)
+  return cross_entropy + epsilon * one_minus_pt
+
+
+def kl_divergence(
+    log_predictions: chex.Array,
+    targets: chex.Array
+) -> chex.Array:
+  """Computes the Kullback-Leibler divergence (relative entropy) loss.
+
+  Measures the information gain achieved if target probability distribution
+  would be used instead of predicted probability distribution.
+
+  References:
+    [Kullback, Leibler, 1951](https://www.jstor.org/stable/2236703)
+
+  Args:
+    log_predictions: Probabilities of predicted distribution with shape [...,
+      dim]. Expected to be in the log-space to avoid underflow.
+    targets: Probabilities of target distribution with shape [..., dim].
+      Expected to be strictly positive.
+
+  Returns:
+    Kullback-Leibler divergence of predicted distribution from target
+    distribution with shape [...].
+  """
+  chex.assert_type([log_predictions, targets], float)
+  loss = targets * (
+      jnp.where(targets == 0, 0, jnp.log(targets)) - log_predictions
+  )
+  return jnp.sum(loss, axis=-1)
+
+
+def kl_divergence_with_log_targets(
+    log_predictions: chex.Array,
+    log_targets: chex.Array
+) -> chex.Array:
+  """Computes the Kullback-Leibler divergence (relative entropy) loss.
+
+  Version of kl_div_loss where targets are given in log-space.
+
+  Args:
+    log_predictions: Probabilities of predicted distribution with shape
+      [..., dim]. Expected to be in the log-space to avoid underflow.
+    log_targets: Probabilities of target distribution with shape [..., dim].
+      Expected to be in the log-space.
+
+  Returns:
+    Kullback-Leibler divergence of predicted distribution from target
+    distribution with shape [...].
+  """
+  chex.assert_type([log_predictions, log_targets], float)
+  loss = jnp.exp(log_targets) * (log_targets - log_predictions)
+  return jnp.sum(loss, axis=-1)
+
+
+def convex_kl_divergence(
+    log_predictions: chex.Array,
+    targets: chex.Array
+) -> chex.Array:
+  """Computes a convex version of the Kullback-Leibler divergence loss.
+
+  Measures the information gain achieved if target probability distribution
+  would be used instead of predicted probability distribution.
+  This version is jointly convex in p (targets) and q (log_predictions).
+
+  References:
+    [Kullback, Leibler, 1951](https://www.jstor.org/stable/2236703)
+
+  Args:
+    log_predictions: Probabilities of predicted distribution with shape [...,
+      dim]. Expected to be in the log-space to avoid underflow.
+    targets: Probabilities of target distribution with shape [..., dim].
+      Expected to be strictly positive.
+
+  Returns:
+    Kullback-Leibler divergence of predicted distribution from target
+    distribution with shape [...].
+  """
+  return kl_divergence(log_predictions, targets) + jnp.sum(
+      jnp.exp(log_predictions) - targets, axis=-1
+  )
+
+
+@functools.partial(chex.warn_only_n_pos_args_in_future, n=4)
+def ctc_loss_with_forward_probs(
+    logits: chex.Array,
+    logit_paddings: chex.Array,
+    labels: chex.Array,
+    label_paddings: chex.Array,
+    blank_id: int = 0,
+    log_epsilon: float = -1e5
+) -> tuple[chex.Array, chex.Array, chex.Array]:
+  r"""Computes CTC loss and CTC forward-probabilities.
+
+  The CTC loss is a loss function based on log-likelihoods of the model that
+  introduces a special blank symbol :math:`\phi` to represent variable-length
+  output sequences.
+
+  Forward probabilities returned by this function, as auxiliary results, are
+  grouped into two part: blank alpha-probability and non-blank alpha
+  probability. Those are defined as follows:
+
+  .. math::
+    \alpha_{\mathrm{BLANK}}(t, n) =
+    \sum_{\pi_{1:t-1}} p(\pi_t = \phi | \pi_{1:t-1}, y_{1:n-1}, \cdots), \\
+    \alpha_{\mathrm{LABEL}}(t, n) =
+    \sum_{\pi_{1:t-1}} p(\pi_t = y_n | \pi_{1:t-1}, y_{1:n-1}, \cdots).
+
+  Here, :math:`\pi` denotes the alignment sequence in the reference
+  [Graves et al, 2006] that is blank-inserted representations of ``labels``.
+  The return values are the logarithms of the above probabilities.
+
+  References:
+    [Graves et al, 2006](https://dl.acm.org/doi/abs/10.1145/1143844.1143891)
+
+  Args:
+    logits: (B, T, K)-array containing logits of each class where B denotes
+      the batch size, T denotes the max time frames in ``logits``, and K
+      denotes the number of classes including a class for blanks.
+    logit_paddings: (B, T)-array. Padding indicators for ``logits``. Each
+      element must be either 1.0 or 0.0, and ``logitpaddings[b, t] == 1.0``
+      denotes that ``logits[b, t, :]`` are padded values.
+    labels: (B, N)-array containing reference integer labels where N denotes
+      the max time frames in the label sequence.
+    label_paddings: (B, N)-array. Padding indicators for ``labels``. Each
+      element must be either 1.0 or 0.0, and ``labelpaddings[b, n] == 1.0``
+      denotes that ``labels[b, n]`` is a padded label. In the current
+      implementation, ``labels`` must be right-padded, i.e. each row
+      ``labelpaddings[b, :]`` must be repetition of zeroes, followed by
+      repetition of ones.
+    blank_id: Id for blank token. ``logits[b, :, blank_id]`` are used as
+      probabilities of blank symbols.
+    log_epsilon: Numerically-stable approximation of log(+0).
+
+  Returns:
+    A tuple ``(loss_value, logalpha_blank, logalpha_nonblank)``. Here,
+    ``loss_value`` is a (B,)-array containing the loss values for each sequence
+    in the batch, ``logalpha_blank`` and ``logalpha_nonblank`` are
+    (T, B, N+1)-arrays where the (t, b, n)-th element denotes
+    \log \alpha_B(t, n) and \log \alpha_L(t, n), respectively, for ``b``-th
+    sequence in the batch.
+  """
+
+  chex.assert_rank(logits, 3)
+  chex.assert_rank(labels, 2)
+  batchsize, unused_maxinputlen, num_classes = logits.shape
+  batchsize_of_labels, maxlabellen = labels.shape
+  chex.assert_equal(batchsize, batchsize_of_labels)
+  chex.assert_equal(labels.shape, label_paddings.shape)
+  chex.assert_equal(logits.shape[:2], logit_paddings.shape)
+
+  logprobs = jax.nn.log_softmax(logits)
+  labellens = maxlabellen - jnp.sum(label_paddings, axis=1).astype(jnp.int32)
+
+  # repeat[b, n] == 1.0 when label[b, n] == label[b, n+1].
+  repeat = (labels[:, :-1] == labels[:, 1:]).astype(jnp.float32)
+  repeat = jnp.pad(repeat, ((0, 0), (0, 1)))
+
+  logprobs_phi = logprobs[:, :, blank_id:blank_id + 1]  # [B, T, 1]
+  logprobs_phi = jnp.transpose(logprobs_phi, (1, 0, 2))  # [T, B, 1]
+
+  one_hot = jax.nn.one_hot(labels, num_classes=num_classes)  # [B, N, K]
+  logprobs_emit = jnp.einsum('btk,bnk->btn', logprobs, one_hot)
+  logprobs_emit = jnp.transpose(logprobs_emit, (1, 0, 2))  # [T, B, N]
+
+  logalpha_phi_init = jnp.ones(
+      (batchsize, maxlabellen + 1)) * log_epsilon  # [B, N]
+  logalpha_phi_init = logalpha_phi_init.at[:, 0].set(0.0)
+  logalpha_emit_init = jnp.ones((batchsize, maxlabellen)) * log_epsilon
+
+  def update_phi_score(phi, added_score):
+    # Update `phi[:, 1:]`` with adding `added_score` in log space.
+    return jnp.concatenate(
+        [phi[:, :1], jnp.logaddexp(phi[:, 1:], added_score)], axis=-1)
+
+  def loop_body(prev, x):
+    prev_phi, prev_emit = prev
+    # emit-to-phi epsilon transition, except if the next label is repetition
+    prev_phi_orig = prev_phi
+    prev_phi = update_phi_score(prev_phi, prev_emit + log_epsilon * repeat)
+
+    logprob_emit, logprob_phi, pad = x
+
+    # phi-to-emit transition
+    next_emit = jnp.logaddexp(prev_phi[:, :-1] + logprob_emit,
+                              prev_emit + logprob_emit)
+    # self-loop transition
+    next_phi = prev_phi + logprob_phi
+    # emit-to-phi blank transition only when the next label is repetition
+    next_phi = update_phi_score(
+        next_phi, prev_emit + logprob_phi + log_epsilon * (1.0 - repeat))
+
+    pad = pad.reshape((batchsize, 1))
+    next_emit = pad * prev_emit + (1.0 - pad) * next_emit
+    next_phi = pad * prev_phi_orig + (1.0 - pad) * next_phi
+
+    return (next_phi, next_emit), (next_phi, next_emit)
+
+  xs = (logprobs_emit, logprobs_phi, logit_paddings.transpose((1, 0)))
+  _, (logalpha_phi,
+      logalpha_emit) = jax.lax.scan(loop_body,
+                                    (logalpha_phi_init, logalpha_emit_init), xs)
+
+  # last row needs to be updated with the last epsilon transition
+  logalpha_phi_last = update_phi_score(logalpha_phi[-1], logalpha_emit[-1])
+  logalpha_phi = logalpha_phi.at[-1].set(logalpha_phi_last)
+
+  # extract per_seq_loss
+  one_hot = jax.nn.one_hot(labellens, num_classes=maxlabellen + 1)  # [B, N+1]
+  per_seq_loss = -jnp.einsum('bn,bn->b', logalpha_phi_last, one_hot)  # pylint:disable=invalid-unary-operand-type
+
+  return per_seq_loss, logalpha_phi, logalpha_emit
+
+
+@functools.partial(chex.warn_only_n_pos_args_in_future, n=4)
+def ctc_loss(
+    logits: chex.Array,
+    logit_paddings: chex.Array,
+    labels: chex.Array,
+    label_paddings: chex.Array,
+    blank_id: int = 0,
+    log_epsilon: float = -1e5
+) -> chex.Array:
+  """Computes CTC loss.
+
+  See docstring for ``ctc_loss_with_forward_probs`` for details.
+
+  Args:
+    logits: (B, T, K)-array containing logits of each class where B denotes
+      the batch size, T denotes the max time frames in ``logits``, and K
+      denotes the number of classes including a class for blanks.
+    logit_paddings: (B, T)-array. Padding indicators for ``logits``. Each
+      element must be either 1.0 or 0.0, and ``logitpaddings[b, t] == 1.0``
+      denotes that ``logits[b, t, :]`` are padded values.
+    labels: (B, N)-array containing reference integer labels where N denotes
+      the max time frames in the label sequence.
+    label_paddings: (B, N)-array. Padding indicators for ``labels``. Each
+      element must be either 1.0 or 0.0, and ``labelpaddings[b, n] == 1.0``
+      denotes that ``labels[b, n]`` is a padded label. In the current
+      implementation, ``labels`` must be right-padded, i.e. each row
+      ``labelpaddings[b, :]`` must be repetition of zeroes, followed by
+      repetition of ones.
+    blank_id: Id for blank token. ``logits[b, :, blank_id]`` are used as
+      probabilities of blank symbols.
+    log_epsilon: Numerically-stable approximation of log(+0).
+
+  Returns:
+    (B,)-array containing loss values for each sequence in the batch.
+  """
+  per_seq_loss, _, _ = ctc_loss_with_forward_probs(
+      logits, logit_paddings, labels, label_paddings,
+      blank_id=blank_id, log_epsilon=log_epsilon)
+  return per_seq_loss
+
+
+@functools.partial(chex.warn_only_n_pos_args_in_future, n=2)
+def sigmoid_focal_loss(
+    logits: chex.Array,
+    labels: chex.Array,
+    alpha: Optional[float] = None,
+    gamma: float = 2.,
+) ->  chex.Array:
+  """Sigmoid focal loss.
+
+  The focal loss is a re-weighted cross entropy for unbalanced problems.
+  Use this loss function if classes are not mutually exclusive.
+  See `sigmoid_binary_cross_entropy` for more information.
+
+  References:
+    Lin et al. 2018. https://arxiv.org/pdf/1708.02002.pdf
+
+  Args:
+    logits: Array of floats. The predictions for each example.
+      The predictions for each example.
+    labels: Array of floats. Labels and logits must have
+      the same shape. The label array must contain the binary
+      classification labels for each element in the data set
+      (0 for the out-of-class and 1 for in-class).
+    alpha: (optional) Weighting factor in range (0,1) to balance
+      positive vs negative examples. Default None (no weighting).
+    gamma: Exponent of the modulating factor (1 - p_t).
+      Balances easy vs hard examples.
+
+  Returns:
+    A loss value array with a shape identical to the logits and target
+    arrays.
+  """
+  alpha = -1 if alpha is None else alpha
+
+  chex.assert_type([logits], float)
+  labels = labels.astype(logits.dtype)
+  # see also the original paper's implementation at:
+  # https://github.com/facebookresearch/fvcore/blob/main/fvcore/nn/focal_loss.py
+  p = jax.nn.sigmoid(logits)
+  ce_loss = sigmoid_binary_cross_entropy(logits, labels)
+  p_t = p * labels + (1 - p) * (1 - labels)
+  loss = ce_loss * ((1 - p_t) ** gamma)
+
+  weighted = lambda loss_arg: (alpha * labels
+                               + (1 - alpha) * (1 - labels)
+                              )*loss_arg
+  not_weighted = lambda loss_arg: loss_arg
+
+  loss = jax.lax.cond(alpha >= 0,
+                      weighted,
+                      not_weighted,
+                      loss)
+
+  return loss

testbed/google-deepmind__optax/optax/losses/_classification_test.py

@@ -0,0 +1,867 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for optax.losses._classification."""
+
+import functools
+
+from absl.testing import absltest
+from absl.testing import parameterized
+import chex
+import jax
+import jax.numpy as jnp
+import jax.test_util as jaxtest
+import numpy as np
+from optax.losses import _classification
+
+
+class SoftmaxCrossEntropyTest(parameterized.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    self.ys = np.array(
+        [
+            [10.0, 1.0, -2.0],
+            [1.0, 4.0, 0.2],
+        ],
+        dtype=np.float32,
+    )
+    self.ts = np.array(
+        [
+            [0.0, 1.0, 0.0],
+            [1.0, 0.0, 0.0],
+        ],
+        dtype=np.float32,
+    )
+    self.exp = np.array(
+        [
+            9.00013,
+            3.0696733,
+        ],
+        dtype=np.float32,
+    )
+
+  @chex.all_variants
+  def test_scalar(self):
+    """Tests for a full batch."""
+    np.testing.assert_allclose(
+        self.variant(_classification.softmax_cross_entropy)(
+            self.ys[0], self.ts[0]
+        ),
+        self.exp[0],
+        atol=1e-4,
+    )
+
+  @chex.all_variants
+  def test_batched(self):
+    """Tests for a full batch."""
+    np.testing.assert_allclose(
+        self.variant(_classification.softmax_cross_entropy)(self.ys, self.ts),
+        self.exp,
+        atol=1e-4,
+    )
+
+  def test_gradient(self):
+    """Tests gradient ok."""
+    jaxtest.check_grads(
+        _classification.softmax_cross_entropy,
+        (self.ys[:2], self.ts[:2]),
+        order=1,
+    )
+
+
+class SafeSoftmaxCrossEntropyTest(parameterized.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    self.ys = np.array(
+        [
+            [10.0, 1.0, -2.0],
+            [1.0, 4.0, 0.2],
+            [-np.inf, 0.0, 0.0],
+            [-np.inf, 0.0, 0.0],
+            [-np.inf, 0.0, -np.inf],
+        ],
+        dtype=np.float32,
+    )
+    self.ts = np.array(
+        [
+            [0.0, 1.0, 0.0],
+            [1.0, 0.0, 0.0],
+            [0.0, 0.5, 0.5],
+            [0.4, 0.3, 0.3],
+            [0.0, 1.0, 0.0],
+        ],
+        dtype=np.float32,
+    )
+    self.exp = np.array(
+        [
+            9.00013,
+            3.0696733,
+            0.693147,
+            np.inf,
+            0.0,
+        ],
+        dtype=np.float32,
+    )
+
+  @chex.all_variants
+  def test_scalar(self):
+    """Tests for a full batch."""
+    np.testing.assert_allclose(
+        self.variant(_classification.safe_softmax_cross_entropy)(
+            self.ys[0], self.ts[0]
+        ),
+        self.exp[0],
+        atol=1e-4,
+    )
+
+  @chex.all_variants
+  def test_batched(self):
+    """Tests for a full batch."""
+    np.testing.assert_allclose(
+        self.variant(_classification.safe_softmax_cross_entropy)(
+            self.ys, self.ts
+        ),
+        self.exp,
+        atol=1e-4,
+    )
+
+  def test_gradient(self):
+    """Tests gradient ok."""
+    jaxtest.check_grads(
+        _classification.safe_softmax_cross_entropy,
+        (self.ys[:2], self.ts[:2]),
+        order=1,
+    )
+
+  def test_against_plain_implementation(self):
+    """Tests against plain implementation which does not handle -inf."""
+
+    plain_val_and_grad = jax.value_and_grad(
+        _classification.softmax_cross_entropy
+    )(self.ys[0], self.ts[0])
+    val_and_grad = jax.value_and_grad(
+        _classification.safe_softmax_cross_entropy
+    )(self.ys[0], self.ts[0])
+    chex.assert_trees_all_close(plain_val_and_grad, val_and_grad, atol=1e-4)
+
+
+class SoftmaxCrossEntropyWithIntegerLabelsTest(parameterized.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    self.ys = np.array([[10.0, 1.0, -2.0], [1.0, 4.0, 0.2]], dtype=np.float32)
+    self.ts = np.array([1, 0], dtype=np.int32)
+
+  @chex.all_variants
+  def test_consistent_with_softmax_cross_entropy_scalar(self):
+    """Tests for a scalar."""
+    exp = _classification.softmax_cross_entropy(
+        self.ys[0], jax.nn.one_hot(self.ts[0], 3)
+    )
+    np.testing.assert_allclose(
+        self.variant(_classification.softmax_cross_entropy_with_integer_labels)(
+            self.ys[0], self.ts[0]
+        ),
+        exp,
+        rtol=1e-6,
+    )
+
+  @chex.all_variants
+  def test_consistent_with_softmax_cross_entropy_batched(self):
+    """Tests for a full batch."""
+    exp = _classification.softmax_cross_entropy(
+        self.ys, jax.nn.one_hot(self.ts, 3)
+    )
+    np.testing.assert_allclose(
+        self.variant(_classification.softmax_cross_entropy_with_integer_labels)(
+            self.ys, self.ts
+        ),
+        exp,
+        rtol=1e-6,
+    )
+
+  def test_gradient(self):
+    """Tests gradient ok."""
+    jaxtest.check_grads(
+        functools.partial(
+            _classification.softmax_cross_entropy_with_integer_labels,
+            labels=self.ts,
+        ),
+        (self.ys,),
+        order=1,
+    )
+
+
+class SigmoidCrossEntropyTest(parameterized.TestCase):
+
+  @parameterized.parameters(
+      dict(
+          preds=np.array([-1e09, -1e-09]),
+          labels=np.array([1.0, 0.0]),
+          expected=5e08,
+      ),
+      dict(
+          preds=np.array([-1e09, -1e-09]),
+          labels=np.array([0.0, 1.0]),
+          expected=0.3465736,
+      ),
+      dict(
+          preds=np.array([1e09, 1e-09]),
+          labels=np.array([1.0, 0.0]),
+          expected=0.3465736,
+      ),
+      dict(
+          preds=np.array([1e09, 1e-09]),
+          labels=np.array([0.0, 1.0]),
+          expected=5e08,
+      ),
+      dict(
+          preds=np.array([-1e09, 1e-09]),
+          labels=np.array([1.0, 0.0]),
+          expected=5e08,
+      ),
+      dict(
+          preds=np.array([-1e09, 1e-09]),
+          labels=np.array([0.0, 1.0]),
+          expected=0.3465736,
+      ),
+      dict(
+          preds=np.array([1e09, -1e-09]),
+          labels=np.array([1.0, 0.0]),
+          expected=0.3465736,
+      ),
+      dict(
+          preds=np.array([1e09, -1e-09]),
+          labels=np.array([0.0, 1.0]),
+          expected=5e08,
+      ),
+      dict(
+          preds=np.array([0.0, 0.0]),
+          labels=np.array([1.0, 0.0]),
+          expected=0.6931472,
+      ),
+      dict(
+          preds=np.array([0.0, 0.0]),
+          labels=np.array([0.0, 1.0]),
+          expected=0.6931472,
+      ),
+  )
+  def testSigmoidCrossEntropy(self, preds, labels, expected):
+    tested = jnp.mean(
+        _classification.sigmoid_binary_cross_entropy(preds, labels)
+    )
+    np.testing.assert_allclose(tested, expected, rtol=1e-6, atol=1e-6)
+
+
+class PolyLossTest(parameterized.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    self.logits = np.array([0.14, 1.456, 2.356, -0.124, -2.47])
+    self.labels = np.array([0.1, 0.15, 0.2, 0.25, 0.3])
+
+    self.batched_logits = np.array([[4.0, 2.0, 1.0], [0.0, 5.0, 1.0]])
+    self.batched_labels = np.array([[1.0, 0.0, 0.0], [0.0, 0.8, 0.2]])
+    # all expected values are computed using tf version of `poly1_cross_entropy`
+    # see page 10 here https://arxiv.org/pdf/2204.12511.pdf for more
+
+  @chex.all_variants
+  @parameterized.parameters(
+      dict(eps=2, expected=4.5317),
+      dict(eps=1, expected=3.7153),
+      dict(eps=-1, expected=2.0827),
+      dict(eps=0, expected=2.8990),
+      dict(eps=-0.5, expected=2.4908),
+      dict(eps=1.15, expected=3.8378),
+      dict(eps=1.214, expected=3.8900),
+      dict(eps=5.45, expected=7.3480),
+  )
+  def test_scalar(self, eps, expected):
+    np.testing.assert_allclose(
+        self.variant(_classification.poly_loss_cross_entropy)(
+            self.logits, self.labels, epsilon=eps
+        ),
+        expected,
+        atol=1e-4,
+    )
+
+  @chex.all_variants
+  @parameterized.parameters(
+      dict(eps=2, expected=np.array([0.4823, 1.2567])),
+      dict(eps=1, expected=np.array([0.3261, 1.0407])),
+      dict(eps=0, expected=np.array([0.1698, 0.8247])),
+      dict(eps=-0.5, expected=np.array([0.0917, 0.7168])),
+      dict(eps=1.15, expected=np.array([0.3495, 1.0731])),
+      dict(eps=1.214, expected=np.array([0.3595, 1.0870])),
+      dict(eps=5.45, expected=np.array([1.0211, 2.0018])),
+  )
+  def test_batched(self, eps, expected):
+    np.testing.assert_allclose(
+        self.variant(_classification.poly_loss_cross_entropy)(
+            self.batched_logits, self.batched_labels, epsilon=eps
+        ),
+        expected,
+        atol=1e-4,
+    )
+
+  @chex.all_variants
+  @parameterized.parameters(
+      dict(
+          logits=np.array(
+              [[4.0, 2.0, 1.0], [0.0, 5.0, 1.0], [0.134, 1.234, 3.235]]
+          ),
+          labels=np.array(
+              [[1.0, 0.0, 0.0], [0.0, 0.8, 0.2], [0.34, 0.33, 0.33]]
+          ),
+      ),
+      dict(
+          logits=np.array([[4.0, 2.0, 1.0], [0.0, 5.0, 1.0]]),
+          labels=np.array([[1.0, 0.0, 0.0], [0.0, 0.8, 0.2]]),
+      ),
+      dict(
+          logits=np.array(
+              [[4.0, 2.0, 1.0, 0.134, 1.3515], [0.0, 5.0, 1.0, 0.5215, 5.616]]
+          ),
+          labels=np.array(
+              [[0.5, 0.0, 0.0, 0.0, 0.5], [0.0, 0.12, 0.2, 0.56, 0.12]]
+          ),
+      ),
+      dict(logits=np.array([1.89, 2.39]), labels=np.array([0.34, 0.66])),
+      dict(logits=np.array([0.314]), labels=np.array([1.0])),
+  )
+  def test_equals_to_cross_entropy_when_eps0(self, logits, labels):
+    np.testing.assert_allclose(
+        self.variant(_classification.poly_loss_cross_entropy)(
+            logits, labels, epsilon=0.0
+        ),
+        self.variant(_classification.softmax_cross_entropy)(logits, labels),
+        atol=1e-4,
+    )
+
+
+class HingeTest(parameterized.TestCase):
+
+  def test_binary(self):
+    label = jnp.array(1)
+    signed_label = jnp.array(2.0 * label - 1.0)
+    score = jnp.array(10.0)
+
+    def reference_impl(label, logit):
+      return jax.nn.relu(1 - logit * (2.0 * label - 1.0))
+
+    expected = reference_impl(label, score)
+    result = _classification.hinge_loss(score, signed_label)
+    np.testing.assert_allclose(result, expected, atol=1e-4)
+
+  def test_batched_binary(self):
+    labels = jnp.array([1, 0])
+    signed_labels = jnp.array(2.0 * labels - 1.0)
+    scores = jnp.array([10.0, 20.0])
+
+    def reference_impl(label, logit):
+      return jax.nn.relu(1 - logit * (2.0 * label - 1.0))
+
+    expected = jax.vmap(reference_impl)(labels, scores)
+    # no need to vmap the optax loss. leading dimensions automatically handled.
+    result = _classification.hinge_loss(scores, signed_labels)
+    np.testing.assert_allclose(result, expected, atol=1e-4)
+
+  def test_multi_class(self):
+    label = jnp.array(1)
+    scores = jnp.array([10.0, 3.0])
+
+    def reference_impl(label, scores):
+      one_hot_label = jax.nn.one_hot(label, scores.shape[-1])
+      return jnp.max(scores + 1.0 - one_hot_label) - scores[label]
+
+    expected = reference_impl(label, scores)
+    result = _classification.multiclass_hinge_loss(scores, label)
+    np.testing.assert_allclose(result, expected, atol=1e-4)
+
+  def test_batched_multi_class(self):
+    label = jnp.array([1, 0])
+    scores = jnp.array([[10.0, 3.0], [11.0, -2.0]])
+
+    def reference_impl(label, scores):
+      one_hot_label = jax.nn.one_hot(label, scores.shape[-1])
+      return jnp.max(scores + 1.0 - one_hot_label) - scores[label]
+
+    expected = jax.vmap(reference_impl)(label, scores)
+    # no need to vmap the optax loss. leading dimensions automatically handled.
+    result = _classification.multiclass_hinge_loss(scores, label)
+    np.testing.assert_allclose(result, expected, atol=1e-4)
+
+
+class SparsemaxTest(parameterized.TestCase):
+
+  def test_binary(self):
+    label = 1
+    score = 10.0
+
+    def reference_impl(label, logit):
+      scores = -(2 * label - 1) * logit
+      if scores <= -1.0:
+        return 0.0
+      elif scores >= 1.0:
+        return scores
+      else:
+        return (scores + 1.0) ** 2 / 4
+
+    expected = reference_impl(label, score)
+    result = _classification.sparsemax_loss(
+        jnp.asarray(score), jnp.asarray(label)
+    )
+    np.testing.assert_allclose(result, expected, atol=1e-4)
+
+  def test_batched_binary(self):
+    labels = jnp.array([1, 0])
+    scores = jnp.array([10.0, 20.0])
+
+    def reference_impl(label, logit):
+      scores = -(2 * label - 1) * logit
+      if scores <= -1.0:
+        return 0.0
+      elif scores >= 1.0:
+        return scores
+      else:
+        return (scores + 1.0) ** 2 / 4
+
+    expected = jnp.asarray([
+        reference_impl(labels[0], scores[0]),
+        reference_impl(labels[1], scores[1]),
+    ])
+    # in the optax loss the leading dimensions are automatically handled.
+    result = _classification.sparsemax_loss(scores, labels)
+    np.testing.assert_allclose(result, expected, atol=1e-4)
+
+
+class ConvexKLDivergenceTest(parameterized.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    self.log_ps = np.array([
+        [-2.9957, -3.5066, -3.9120, -1.2040, -0.6931, -2.3026],
+        [-1.6094, -1.6094, -1.6094, -2.3026, -1.8971, -1.8971],
+    ])
+    self.qs = np.array(
+        [[0.2, 0.2, 0.2, 0.1, 0.15, 0.15], [0.05, 0.03, 0.02, 0.3, 0.5, 0.0]]
+    )
+
+    # Computed convex kullback-leibler divergence of P from Q.
+    self.exp = np.array([0.88757247, 0.859308])
+
+  @chex.all_variants
+  def test_scalar(self):
+    np.testing.assert_allclose(
+        self.variant(_classification.convex_kl_divergence)(
+            self.log_ps[0], self.qs[0]
+        ),
+        self.exp[0],
+        atol=1e-4,
+    )
+
+  @chex.all_variants
+  def test_batched(self):
+    np.testing.assert_allclose(
+        self.variant(_classification.convex_kl_divergence)(
+            self.log_ps, self.qs
+        ),
+        self.exp,
+        atol=1e-4,
+    )
+
+
+class PerceptronTest(parameterized.TestCase):
+
+  def test_binary(self):
+    label = jnp.array(1)
+    signed_label = jnp.array(2.0 * label - 1.0)
+    score = jnp.array(10.0)
+
+    def reference_impl(label, logit) -> float:
+      return jax.nn.relu(-logit * (2.0 * label - 1.0))
+
+    expected = reference_impl(label, score)
+    result = _classification.perceptron_loss(score, signed_label)
+    np.testing.assert_allclose(result, expected, atol=1e-4)
+
+  def test_batched_binary(self):
+    labels = jnp.array([1, 0])
+    signed_labels = jnp.array(2.0 * labels - 1.0)
+    scores = jnp.array([10.0, 20.0])
+
+    def reference_impl(label, logit) -> float:
+      return jax.nn.relu(-logit * (2.0 * label - 1.0))
+
+    expected = jax.vmap(reference_impl)(labels, scores)
+    # no need to vmap the optax loss. leading dimensions automatically handled.
+    result = _classification.perceptron_loss(scores, signed_labels)
+    np.testing.assert_allclose(result, expected, atol=1e-4)
+
+  def test_multi_class(self):
+    label = jnp.array(1)
+    scores = jnp.array([10.0, 3.0])
+
+    def reference_impl(label, scores):
+      return jnp.max(scores) - scores[label]
+
+    expected = reference_impl(label, scores)
+    result = _classification.multiclass_perceptron_loss(scores, label)
+    np.testing.assert_allclose(result, expected, atol=1e-4)
+
+  def test_batched_multi_class(self):
+    label = jnp.array([1, 0])
+    scores = jnp.array([[10.0, 3.0], [11.0, -2.0]])
+
+    def reference_impl(label, scores):
+      return jnp.max(scores) - scores[label]
+
+    expected = jax.vmap(reference_impl)(label, scores)
+    # no need to vmap the optax loss. leading dimensions automatically handled.
+    result = _classification.multiclass_perceptron_loss(scores, label)
+    np.testing.assert_allclose(result, expected, atol=1e-4)
+
+
+class KLDivergenceTest(parameterized.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    self.log_ps = np.array([
+        [-2.9957, -3.5066, -3.9120, -1.2040, -0.6931, -2.3026],
+        [-1.6094, -1.6094, -1.6094, -2.3026, -1.8971, -1.8971],
+    ])
+    self.qs = np.array(
+        [[0.2, 0.2, 0.2, 0.1, 0.15, 0.15], [0.05, 0.03, 0.02, 0.3, 0.5, 0.0]]
+    )
+    # Computed kullback-leibler divergence of P from Q.
+    self.exp = np.array([0.8875577, 0.7592807])
+
+  @chex.all_variants
+  def test_scalar(self):
+    np.testing.assert_allclose(
+        self.variant(_classification.kl_divergence)(self.log_ps[0], self.qs[0]),
+        self.exp[0],
+        atol=1e-4,
+    )
+
+  @chex.all_variants
+  def test_batched(self):
+    np.testing.assert_allclose(
+        self.variant(_classification.kl_divergence)(self.log_ps, self.qs),
+        self.exp,
+        atol=1e-4,
+    )
+
+
+class KLDivergenceWithLogTargetsTest(parameterized.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    self.log_ps = np.array([
+        [-2.9957, -3.5066, -3.9120, -1.2040, -0.6931, -2.3026],
+        [-1.6094, -1.6094, -1.6094, -2.3026, -1.8971, -1.8971],
+    ])
+    self.qs = np.array([
+        [-1.6094, -1.6094, -1.6094, -2.3026, -1.8971, -1.8971],
+        [-2.9957, -3.5066, -3.9120, -1.2040, -0.6931, -2.3026],
+    ])
+    # Computed kullback-leibler divergence of P from Q.
+    self.exp = np.array([0.8875625, 0.7187435584901326])
+
+  @chex.all_variants
+  def test_scalar(self):
+    np.testing.assert_allclose(
+        self.variant(_classification.kl_divergence_with_log_targets)(
+            self.log_ps[0], self.qs[0]
+        ),
+        self.exp[0],
+        atol=1e-4,
+    )
+
+  @chex.all_variants
+  def test_batched(self):
+    np.testing.assert_allclose(
+        self.variant(_classification.kl_divergence_with_log_targets)(
+            self.log_ps, self.qs
+        ),
+        self.exp,
+        atol=1e-4,
+    )
+
+
+def _lengths_to_paddings(lengths: chex.Array, maxlength: int) -> chex.Array:
+  indices = jnp.arange(maxlength).reshape((1,) * lengths.ndim + (maxlength,))
+  lengths = jnp.expand_dims(lengths, axis=-1)
+  elem_valid = indices < lengths
+  return np.logical_not(elem_valid).astype(np.float32)
+
+
+def _average_ctc_loss(
+    logprobs: chex.Array,
+    logprob_paddings: chex.Array,
+    labels: chex.Array,
+    label_paddings: chex.Array,
+) -> chex.Array:
+  return jnp.average(
+      _classification.ctc_loss(
+          logprobs, logprob_paddings, labels, label_paddings
+      )
+  )
+
+
+class CTCTest(parameterized.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    np.random.seed(1234)
+    self._rtol = 5e-3 if jax.default_backend() != 'cpu' else 1e-6
+
+  @chex.all_variants
+  def test_with_one_to_one_alignment(self):
+    # when inputsteps and outputsteps are equal, no blank will be allowed.
+    batchsize = 8
+    steps = 50
+    nclasses = 40
+    logits = np.random.randn(batchsize, steps, nclasses)
+    labels = np.random.uniform(1, nclasses, size=(batchsize, steps)).astype(
+        np.int32
+    )
+
+    # This function only covers the cases without same-label repetition.
+    # `test_repeat_with_one_to_one_alignment` below complements those cases.
+    # So, redraw the samples for satisfying the non-repetition constraint.
+    for n in range(labels.shape[0]):
+      for t in range(1, labels.shape[1]):
+        while labels[n, t] == labels[n, t - 1]:
+          labels[n, t] = np.random.uniform(1, nclasses)
+
+    results = self.variant(_classification.ctc_loss_with_forward_probs)(
+        logits, np.zeros(logits.shape[:2]), labels, np.zeros(labels.shape)
+    )
+    (per_seq_loss, logalpha_blank, logalpha_emit) = results
+
+    logprobs = jax.nn.log_softmax(logits)
+    for b in range(batchsize):
+      p = 0.0
+      for t in range(steps):
+        p += logprobs[b, t, labels[b, t]]
+      np.testing.assert_allclose(np.array(-p), per_seq_loss[b], rtol=self._rtol)
+
+      # Check forward-probabilities.
+      # 1. All-phi path: logalpha_blank[-1, b, 0] must be a probability of
+      #   the path that outputs blank symbols for all the frames.
+      np.testing.assert_allclose(
+          logalpha_blank[-1, b, 0], np.sum(logprobs[b, :, 0]), rtol=self._rtol
+      )
+
+      # 2. After emitting all the labels
+      #   the negated loss must be identical with the forward probability of
+      #   paths after consuming all the labels (because one-to-one alignment
+      #   doesn't allow extra blank symbols)
+      np.testing.assert_allclose(
+          logalpha_emit[-1, b, steps - 1], -per_seq_loss[b], rtol=self._rtol
+      )
+      #   and, this forward probability must be copied to the blank forward
+      #   probability of the next step.
+      np.testing.assert_allclose(
+          logalpha_blank[-1, b, steps], -per_seq_loss[b], rtol=self._rtol
+      )
+
+  @chex.all_variants
+  def test_with_one_to_one_alignment_and_paddings(self):
+    batch_size = 5
+    nclasses = 13
+    steps = 7
+    logits = np.random.normal(size=[batch_size, steps, nclasses])
+    logprobs = jax.nn.log_softmax(logits)
+
+    labels = []
+    for n in range(batch_size):
+      row = list(range(1, nclasses))
+      np.random.shuffle(row)
+      labels.append(row[:steps])
+    labels = np.array(labels)
+
+    lengths = np.random.randint(3, 6, size=(batch_size,))
+    paddings = _lengths_to_paddings(lengths, steps)
+
+    actual_loss = self.variant(_classification.ctc_loss)(
+        logits, paddings, labels, paddings
+    )
+
+    value_and_grad = self.variant(jax.value_and_grad(_average_ctc_loss))
+    unused_avg_loss, actual_gradients = value_and_grad(
+        logits, paddings, labels, paddings
+    )
+
+    for n in range(batch_size):
+      expected_loss = -sum(
+          logprobs[n, t, k] for t, k in enumerate(labels[n, : lengths[n]])
+      )
+      np.testing.assert_allclose(expected_loss, actual_loss[n], rtol=self._rtol)
+
+      expected_gradients = np.array(jax.nn.softmax(logits[n]))
+      expected_gradients[lengths[n] :] = 0.0
+      for t, k in enumerate(labels[n, : lengths[n]]):
+        expected_gradients[t, k] -= 1.0
+      expected_gradients /= batch_size
+      np.testing.assert_allclose(
+          expected_gradients, actual_gradients[n], rtol=self._rtol
+      )
+
+  @chex.all_variants
+  def test_repeat_with_one_to_one_alignment(self):
+    # test if it can correctly handle the same-label repetition.
+    nclasses = 5
+    labels = np.array([
+        [1, 2, 2, 3],
+        [2, 3, 4, 4],
+        [1, 1, 1, 1],
+        [1, 1, 2, 3],
+        [1, 1, 1, 2],
+    ])
+    expected_alignment = [  # expected minimal alignment
+        [1, 2, 0, 2, 3],
+        [2, 3, 4, 0, 4],
+        [1, 0, 1, 0, 1, 0, 1],
+        [1, 0, 1, 2, 3],
+        [1, 0, 1, 0, 1, 2],
+    ]
+    batch_size = len(labels)
+    label_lens = np.array([4] * batch_size)
+    label_steps = 6
+    # Designed to have two padding elements on the right.
+    labels = np.pad(labels, [(0, 0), (0, label_steps - labels.shape[1])])
+    label_paddings = _lengths_to_paddings(label_lens, label_steps)
+
+    logit_lengths = np.array([len(seq) for seq in expected_alignment])
+    logit_steps = max(logit_lengths)
+    logits = np.random.randn(batch_size, logit_steps, nclasses)
+    logit_paddings = _lengths_to_paddings(logit_lengths, logit_steps)
+
+    per_seq_loss = self.variant(_classification.ctc_loss)(
+        logits, logit_paddings, labels, label_paddings
+    )
+
+    logprobs = jax.nn.log_softmax(logits)
+    for n in range(batch_size):
+      expected_loss = -sum(
+          logprobs[n, t, k] for t, k in enumerate(expected_alignment[n])
+      )
+      np.testing.assert_allclose(
+          jnp.array(expected_loss), per_seq_loss[n], rtol=self._rtol
+      )
+
+
+class SigmoidFocalLossTest(parameterized.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    self.ys = np.array([[2.0, 0.1, -2.0], [0.3, -0.1, 1.2]], dtype=np.float32)
+    self.ts = np.array([[0.0, 0.0, 1.0], [1.0, 0.0, 0.0]])
+    self._rtol = 5e-3 if jax.default_backend() != 'cpu' else 1e-6
+
+    logit = lambda x: jnp.log(x / (1.0 - x))
+    self.large_ys = logit(jnp.array([0.9, 0.98, 0.3, 0.99]))
+    self.small_ys = logit(jnp.array([0.1, 0.02, 0.09, 0.15]))
+    self.ones_ts = jnp.array([1.0, 1.0, 1.0, 1.0])
+
+  @chex.all_variants
+  def test_focal_equals_ce(self):
+    """If gamma == 0 and alpha == 0 we expect a CE loss."""
+    np.testing.assert_allclose(
+        self.variant(_classification.sigmoid_focal_loss)(
+            self.ys, self.ts, gamma=0.0
+        ),
+        _classification.sigmoid_binary_cross_entropy(self.ys, self.ts),
+        rtol=self._rtol,
+    )
+
+  @chex.all_variants
+  def test_scale(self):
+    """This test should catch problems with p_t."""
+    gamma = 2
+    focal_loss = self.variant(_classification.sigmoid_focal_loss)(
+        self.ys, self.ts, gamma=gamma
+    )
+    p = jax.nn.sigmoid(self.ys)
+    ce_loss = _classification.sigmoid_binary_cross_entropy(self.ys, self.ts)
+    p_t = p * self.ts + (1 - p) * (1 - self.ts)
+    scale = (1 - p_t) ** gamma
+    focal_scale = focal_loss / ce_loss
+    np.testing.assert_allclose(focal_scale, scale, rtol=self._rtol)
+
+  @chex.all_variants
+  def test_large_logit_fl_less_than_ce(self):
+    """If gamma == 2 and alpha == 0.5, the impact of large logits is reduced."""
+    focal_loss = self.variant(_classification.sigmoid_focal_loss)(
+        self.large_ys, self.ones_ts, gamma=2, alpha=0.5
+    )
+    ce_loss = _classification.sigmoid_binary_cross_entropy(
+        self.large_ys, self.ones_ts
+    )
+    loss_ratio = ce_loss / focal_loss
+    expected_ratio = 2.0 / ((1.0 - jax.nn.sigmoid(self.large_ys)) ** 2)
+    np.testing.assert_allclose(loss_ratio, expected_ratio, rtol=self._rtol)
+
+  @chex.all_variants
+  def test_small_logit_fl_less_than_ce(self):
+    """If gamma == 2, small logits retain their weight."""
+    focal_loss = self.variant(_classification.sigmoid_focal_loss)(
+        self.small_ys, self.ones_ts, gamma=2
+    )
+    ce_loss = _classification.sigmoid_binary_cross_entropy(
+        self.small_ys, self.ones_ts
+    )
+    loss_ratio = ce_loss / focal_loss
+    expected_ratio = 1.0 / ((1.0 - jax.nn.sigmoid(self.small_ys)) ** 2)
+    np.testing.assert_allclose(loss_ratio, expected_ratio, rtol=self._rtol)
+
+  @chex.all_variants
+  def test_alpha_one(self):
+    """Test if re-weighting with alpha=1 is ok."""
+    np.testing.assert_allclose(
+        self.variant(_classification.sigmoid_focal_loss)(
+            self.ys, self.ts, gamma=0.0, alpha=1
+        ),
+        _classification.sigmoid_binary_cross_entropy(self.ys, self.ts)
+        * self.ts,
+        rtol=self._rtol,
+    )
+
+  @chex.all_variants
+  def test_ignore_positive(self):
+    """If alpha == 0 positive examples do not matter."""
+    focal_loss = self.variant(_classification.sigmoid_focal_loss)(
+        self.ys, self.ts, alpha=0
+    )
+    ce_loss = _classification.sigmoid_binary_cross_entropy(self.ys, self.ts)
+    assert all(ce_loss[self.ts == 1] > 0)
+    assert all(focal_loss[self.ts == 1] == 0)
+
+  @chex.all_variants
+  def test_ignore_negative(self):
+    """If alpha == 1 negative examples do not matter."""
+    focal_loss = self.variant(_classification.sigmoid_focal_loss)(
+        self.ys, self.ts, alpha=1
+    )
+    ce_loss = _classification.sigmoid_binary_cross_entropy(self.ys, self.ts)
+    assert all(ce_loss[self.ts == 0] > 0)
+    assert all(focal_loss[self.ts == 0] == 0)
+
+
+if __name__ == '__main__':
+  absltest.main()

testbed/google-deepmind__optax/optax/losses/_fenchel_young_test.py

@@ -0,0 +1,63 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for optax.losses._fenchel_young."""
+
+from absl.testing import absltest
+import chex
+import jax
+import jax.numpy as jnp
+from jax.scipy.special import logsumexp
+
+from optax.losses import _classification
+from optax.losses import _fenchel_young
+
+
+def one_hot_argmax(inputs: jnp.ndarray) -> jnp.ndarray:
+  """An argmax one-hot function for arbitrary shapes."""
+  inputs_flat = jnp.reshape(inputs, (-1))
+  flat_one_hot = jax.nn.one_hot(jnp.argmax(inputs_flat), inputs_flat.shape[0])
+  return jnp.reshape(flat_one_hot, inputs.shape)
+
+
+class FenchelYoungTest(chex.TestCase):
+
+  @chex.all_variants
+  def test_fenchel_young_reg(self):
+    # Checks the behavior of the Fenchel-Young loss.
+    fy_loss = self.variant(_fenchel_young.make_fenchel_young_loss(logsumexp))
+    rng = jax.random.PRNGKey(0)
+    rngs = jax.random.split(rng, 2)
+    theta_true = jax.random.uniform(rngs[0], (8, 5))
+    y_true = jax.vmap(jax.nn.softmax)(theta_true)
+    theta_random = jax.random.uniform(rngs[1], (8, 5))
+    y_random = jax.vmap(jax.nn.softmax)(theta_random)
+    grad_random = jax.vmap(jax.grad(fy_loss))(theta_random, y_true)
+    # Checks that the gradient of the loss takes the correct form.
+    chex.assert_trees_all_close(grad_random, y_random - y_true, rtol=1e-4)
+    y_one_hot = jax.vmap(one_hot_argmax)(theta_true)
+    int_one_hot = jnp.where(y_one_hot == 1.)[1]
+    loss_one_hot = jax.vmap(fy_loss)(theta_random, y_one_hot)
+    log_loss = jax.vmap(
+        _classification.softmax_cross_entropy_with_integer_labels)(
+            theta_random, int_one_hot)
+    # Checks that the FY loss associated to logsumexp is correct.
+    chex.assert_trees_all_close(loss_one_hot, log_loss, rtol=1e-4)
+    # Checks that vmapping or not is equivalent.
+    loss_one_hot_no_vmap = fy_loss(theta_random, y_one_hot)
+    chex.assert_trees_all_close(loss_one_hot, loss_one_hot_no_vmap, rtol=1e-4)
+
+
+if __name__ == "__main__":
+  absltest.main()

testbed/google-deepmind__optax/optax/losses/_regression_test.py

@@ -0,0 +1,178 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for optax.losses._regression."""
+
+from absl.testing import absltest
+from absl.testing import parameterized
+
+import chex
+import jax.numpy as jnp
+import numpy as np
+
+from optax.losses import _regression
+
+
+class SquaredErrorTest(parameterized.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    self.ys = jnp.array([-2., -1., 0.5, 1.])
+    self.ts = jnp.array([-1.5, 0., -1, 1.])
+    # compute expected outputs in numpy.
+    self.exp = (self.ts - self.ys) ** 2
+
+  @chex.all_variants
+  def test_scalar(self):
+    np.testing.assert_allclose(
+        self.variant(_regression.squared_error)(
+            self.ys[0], self.ts[0]), self.exp[0])
+
+  @chex.all_variants
+  def test_batched(self):
+    np.testing.assert_allclose(
+        self.variant(_regression.squared_error)(
+            self.ys, self.ts), self.exp)
+
+  @chex.all_variants
+  def test_shape_mismatch(self):
+    with self.assertRaises(AssertionError):
+      _ = self.variant(_regression.squared_error)(
+          self.ys, jnp.expand_dims(self.ts, axis=-1))
+
+
+class L2LossTest(parameterized.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    self.ys = jnp.array([-2., -1., 0.5, 1.])
+    self.ts = jnp.array([-1.5, 0., -1, 1.])
+    # compute expected outputs in numpy.
+    self.exp = 0.5 * (self.ts - self.ys) ** 2
+
+  @chex.all_variants
+  def test_scalar(self):
+    np.testing.assert_allclose(
+        self.variant(_regression.l2_loss)(self.ys[0], self.ts[0]), self.exp[0])
+
+  @chex.all_variants
+  def test_batched(self):
+    np.testing.assert_allclose(
+        self.variant(_regression.l2_loss)(self.ys, self.ts), self.exp)
+
+  @chex.all_variants
+  def test_shape_mismatch(self):
+    with self.assertRaises(AssertionError):
+      _ = self.variant(_regression.l2_loss)(
+          self.ys, jnp.expand_dims(self.ts, axis=-1))
+
+
+class HuberLossTest(parameterized.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    self.ys = np.array([-2.0, 0.5, 0., 0.5, 2.0, 4.0, 132.])
+    self.ts = np.array([0.0, -0.5, 0., 1., 1.0, 2.0, 0.3])
+    # computed expected outputs manually.
+    self.exp = np.array([1.5, 0.5, 0., 0.125, 0.5, 1.5, 131.2])
+
+  @chex.all_variants
+  def test_scalar(self):
+    np.testing.assert_allclose(
+        self.variant(_regression.huber_loss)(
+            self.ys[0], self.ts[0], delta=1.0),
+        self.exp[0])
+
+  @chex.all_variants
+  def test_batched(self):
+    np.testing.assert_allclose(
+        self.variant(_regression.huber_loss)(
+            self.ys, self.ts, delta=1.0),
+        self.exp)
+
+
+# TODO(b/188419459): add test for grad and second order grad.
+class LogCoshTest(parameterized.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    # Test large values for overflow
+    self.ys = jnp.array([500, -2., -1., 0.5, 1.])
+    self.ts = jnp.array([-200, -1.5, 0., -1, 1.])
+    # computed using tensorflow.keras.losses.log_cosh v2.4.1
+    self.exp = jnp.array([699.3068, 0.12011445, 0.4337809, 0.85544014, 0.])
+    self.exp_ys_only = jnp.array(
+        [499.30685, 1.3250027, 0.4337809, 0.12011451, 0.43378082])
+
+  @chex.all_variants
+  def test_scalar(self):
+    out = self.variant(_regression.log_cosh)(self.ys[0], self.ts[0])
+    np.testing.assert_allclose(out, self.exp[0], atol=1e-5)
+
+  @chex.all_variants
+  def test_batched(self):
+    out = self.variant(_regression.log_cosh)(self.ys, self.ts)
+    np.testing.assert_allclose(out, self.exp, atol=1e-5)
+
+  @chex.all_variants
+  def test_scalar_predictions_only(self):
+    out = self.variant(_regression.log_cosh)(self.ys[0])
+    np.testing.assert_allclose(out, self.exp_ys_only[0], atol=1e-5)
+
+  @chex.all_variants
+  def test_batched_predictions_only(self):
+    out = self.variant(_regression.log_cosh)(self.ys)
+    np.testing.assert_allclose(out, self.exp_ys_only, atol=1e-5)
+
+
+class CosineDistanceTest(parameterized.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    self.ys = np.array([[10., 1., -2.], [1., 4., 0.2]], dtype=np.float32)
+    self.ts = np.array([[0., 1.2, 0.2], [1., -0.3, 0.]], dtype=np.float32)
+    # distance computed expected output from `scipy 1.20`.
+    self.exp = np.array([0.9358251989, 1.0464068465], dtype=np.float32)
+
+  @chex.all_variants
+  def test_scalar_distance(self):
+    """Tests for a full batch."""
+    np.testing.assert_allclose(
+        self.variant(_regression.cosine_distance)(self.ys[0], self.ts[0]),
+        self.exp[0], atol=1e-4)
+
+  @chex.all_variants
+  def test_scalar_similarity(self):
+    """Tests for a full batch."""
+    np.testing.assert_allclose(
+        self.variant(_regression.cosine_similarity)(self.ys[0], self.ts[0]),
+        1. - self.exp[0], atol=1e-4)
+
+  @chex.all_variants
+  def test_batched_distance(self):
+    """Tests for a full batch."""
+    np.testing.assert_allclose(
+        self.variant(_regression.cosine_distance)(self.ys, self.ts),
+        self.exp, atol=1e-4)
+
+  @chex.all_variants
+  def test_batched_similarity(self):
+    """Tests for a full batch."""
+    np.testing.assert_allclose(
+        self.variant(_regression.cosine_similarity)(self.ys, self.ts),
+        1. - self.exp, atol=1e-4)
+
+
+if __name__ == '__main__':
+  absltest.main()

testbed/google-deepmind__optax/optax/monte_carlo/__init__.py

@@ -0,0 +1,22 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Utilities for efficient monte carlo gradient estimation."""
+
+from optax.monte_carlo.control_variates import control_delta_method
+from optax.monte_carlo.control_variates import control_variates_jacobians
+from optax.monte_carlo.control_variates import moving_avg_baseline
+from optax.monte_carlo.stochastic_gradient_estimators import measure_valued_jacobians
+from optax.monte_carlo.stochastic_gradient_estimators import pathwise_jacobians
+from optax.monte_carlo.stochastic_gradient_estimators import score_function_jacobians

testbed/google-deepmind__optax/optax/monte_carlo/control_variates.py

@@ -0,0 +1,423 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+r"""Implementation of control variates.
+
+  We are interested in computing the gradient using control variates:
+  \nabla_{\theta} E_{p(x; \theta)} f(x)
+    = \nabla_{\theta} [E_{p(x; \theta)} f(x) - h(x; \theta) + E_{p(x; \theta)}]
+    = \nabla_{\theta} [E_{p(x; \theta)} f(x) - h(x; \theta)]
+        + \nabla_{\theta} E_{p(x; \theta)}]
+   = \nabla_{\theta} [E_{p(x; \theta)} f(x) - h(x; \theta)]
+        + \nabla_{\theta} E_{p(x; \theta)}]
+  = \nabla_{\theta} \int {p(x; \theta)} (f(x) - h(x; \theta)) dx
+       + \nabla_{\theta} E_{p(x; \theta)}]
+  =  \int \nabla_{\theta} {p(x; \theta)} (f(x) - h(x; \theta)) dx
+       + [E_{p(x; \theta)} \nabla_{\theta} (f(x) - h(x; \theta))
+       + \nabla_{\theta} E_{p(x; \theta)}]
+  =  \int \nabla_{\theta} {p(x; \theta)} (f(x) - h(x; \theta)) dx
+       - [E_{p(x; \theta)} \nabla_{\theta} h(x; \theta)
+       + \nabla_{\theta} E_{p(x; \theta)}]
+
+  The above computation is performed in `control_variates_jacobians`.
+
+  When adding a new control variate, one does not need to implement the jacobian
+  computation, but instead has to implement the forward computation.
+
+  Each control variate implemented has to satisfy the following API:
+    * control_variate(function)
+        This returns a tuple of three functions:
+           * The first element of the tuple is a function which returns the
+              control variate value for a set of samples. It takes in as
+              arguments the parameters used to construct the distribution,
+              the distributional samples, and the state of the control variate
+              (if any). The return value of this function will have shape
+              `num_samples`, where `num_samples` is the number of samples
+              provided as input.
+           * The second is a function returns the expected value of the control
+              variate. The input arguments of this function are the parameters
+              of the distribution and the state of the control variate.
+           * The third is a function which updates the state of the control
+              variate, and returns the updated states.
+
+  For examples, see `control_delta_method` and `moving_avg_baseline`.
+"""
+from typing import Any, Callable, Sequence
+
+import chex
+import jax
+import jax.numpy as jnp
+
+from optax._src import base
+
+
+CvState = Any
+ComputeCv = Callable[[base.Params, chex.Array, CvState], chex.Array]
+CvExpectedValue = Callable[[base.Params, CvState], CvState]
+UpdateCvState = Callable[[base.Params, chex.Array, CvState], CvState]
+ControlVariate = tuple[ComputeCv, CvExpectedValue, UpdateCvState]
+
+
+def control_delta_method(
+    function: Callable[[chex.Array], float]) -> ControlVariate:
+  """The control delta covariate method.
+
+  Control variate obtained by performing a second order Taylor expansion
+    on the cost function f at the mean of the input distribution.
+
+  Only implemented for Gaussian random variables.
+
+  For details, see: https://icml.cc/2012/papers/687.pdf
+
+  Args:
+    function: The function for which to compute the control variate.
+      The function takes in one argument (a sample from the distribution) and
+      returns a floating point value.
+
+  Returns:
+    A tuple of three functions, to compute the control variate, the
+    expected value of the control variate, and to update the control variate
+    state.
+  """
+
+  def delta(
+      params: base.Params,
+      sample: chex.Array,
+      state: CvState = None) -> chex.Array:
+    """"Second order expansion of `function` at the mean of the input dist."""
+    del state
+    mean_dist = params[0]
+    centered_sample = sample - mean_dist
+    # Function is a function of samples. Here, we use the mean as the input
+    # since we do a Taylor expansion of function around the mean.
+    grads = jax.grad(function)(mean_dist)
+    hessians = jax.hessian(function)(mean_dist)
+    assert hessians.ndim == 2
+    control_variate = function(mean_dist)
+    control_variate += jnp.dot(centered_sample, grads)
+    control_variate += jnp.dot(
+        jnp.dot(centered_sample, hessians), centered_sample) / 2.
+    return control_variate
+
+  def expected_value_delta(
+      params: base.Params, state: CvState) -> jax.Array:
+    """"Expected value of second order expansion of `function` at dist mean."""
+    del state
+    mean_dist = params[0]
+    var_dist = jnp.square(jnp.exp(params[1]))
+    hessians = jax.hessian(function)(mean_dist)
+
+    assert hessians.ndim == 2
+    hess_diags = jnp.diag(hessians)
+    assert hess_diags.ndim == 1
+
+    # Trace (Hessian * Sigma) and we use that Sigma is diagonal.
+    expected_second_order_term = jnp.sum(var_dist * hess_diags) / 2.
+
+    expected_control_variate = function(mean_dist)
+    expected_control_variate += expected_second_order_term
+    return expected_control_variate
+
+  def update_state(
+      params: base.Params,
+      samples: chex.Array,
+      state: CvState = None) -> CvState:
+    """"No state kept, so no operation is done."""
+    del params, samples
+    return state
+
+  return delta, expected_value_delta, update_state
+
+
+def moving_avg_baseline(
+    function: Callable[[chex.Array], float],
+    decay: float = 0.99,
+    zero_debias: bool = True,
+    use_decay_early_training_heuristic=True) -> ControlVariate:
+  """A moving average baseline.
+
+  It has no effect on the pathwise or measure valued estimator.
+
+  Args:
+    function: The function for which to compute the control variate.
+      The function takes in one argument (a sample from the distribution) and
+      returns a floating point value.
+    decay: The decay rate for the moving average.
+    zero_debias: Whether or not to use zero debiasing for the moving average.
+    use_decay_early_training_heuristic: Whether or not to use a heuristic which
+      overrides the decay value early in training based on
+      min(decay, (1.0 + i) / (10.0 + i)). This stabilises training and was
+      adapted from the Tensorflow codebase.
+
+  Returns:
+    A tuple of three functions, to compute the control variate, the
+    expected value of the control variate, and to update the control variate
+    state.
+  """
+  def moving_avg(
+      params: base.Params,
+      samples: chex.Array,
+      state: CvState = None) -> CvState:
+    """"Return the moving average."""
+    del params, samples
+    return state[0]
+
+  def expected_value_moving_avg(
+      params: base.Params, state: CvState) -> chex.Array:
+    """"Return the moving average."""
+    del params
+    return state[0]
+
+  def update_state(
+      params: base.Params,
+      samples: chex.Array,
+      state: CvState = None) -> CvState:
+    """"Update the moving average."""
+    del params
+    value, i = state
+
+    if use_decay_early_training_heuristic:
+      iteration_decay = jnp.minimum(decay, (1.0 + i) / (10.0 + i))
+    else:
+      iteration_decay = decay
+
+    updated_value = iteration_decay * value
+    updated_value += (1 - iteration_decay) * jnp.mean(
+        jax.vmap(function)(samples))
+
+    if zero_debias:
+      updated_value /= (jnp.ones([]) - jnp.power(iteration_decay, i + 1))
+
+    return (jax.lax.stop_gradient(updated_value), i + 1)
+
+  return moving_avg, expected_value_moving_avg, update_state
+
+
+def _map(cv, params, samples, state):
+  return jax.vmap(lambda x: cv(params, x, state))(samples)
+
+
+def control_variates_jacobians(
+    function: Callable[[chex.Array], float],
+    control_variate_from_function: Callable[
+        [Callable[[chex.Array], float]], ControlVariate
+    ],
+    grad_estimator: Callable[..., jnp.ndarray],
+    params: base.Params,
+    dist_builder: Callable[..., Any],
+    rng: chex.PRNGKey,
+    num_samples: int,
+    control_variate_state: CvState = None,
+    estimate_cv_coeffs: bool = False,
+    estimate_cv_coeffs_num_samples: int = 20,
+) -> tuple[Sequence[chex.Array], CvState]:
+  r"""Obtain jacobians using control variates.
+
+  We will compute each term individually. The first term will use stochastic
+  gradient estimation. The second term will be computes using Monte
+  Carlo estimation and automatic differentiation to compute
+  \nabla_{\theta} h(x; \theta). The the third term will be computed using
+  automatic differentiation, as we restrict ourselves to control variates
+  which compute this expectation in closed form.
+
+  This function updates the state of the control variate (once), before
+  computing the control variate coefficients.
+
+  Args:
+    function: Function f(x) for which to estimate grads_{params} E_dist f(x).
+      The function takes in one argument (a sample from the distribution) and
+      returns a floating point value.
+    control_variate_from_function: The control variate to use to reduce
+      variance. See `control_delta_method` and `moving_avg_baseline` examples.
+    grad_estimator: The gradient estimator to be used to compute the gradients.
+      Note that not all control variates will reduce variance for all
+      estimators. For example, the `moving_avg_baseline` will make no difference
+      to the measure valued or pathwise estimators.
+    params: A tuple of jnp arrays.
+      The parameters for which to construct the distribution and for which we
+      want to compute the jacobians.
+    dist_builder: a constructor which builds a distribution given the input
+      parameters specified by params. `dist_builder(params)` should return a
+      valid distribution.
+    rng: a PRNGKey key.
+    num_samples: Int, the number of samples used to compute the grads.
+    control_variate_state: The control variate state. This is used for control
+      variates which keep states (such as the moving average baselines).
+    estimate_cv_coeffs: Boolean. Whether or not to estimate the optimal control
+      variate coefficient via `estimate_control_variate_coefficients`.
+    estimate_cv_coeffs_num_samples: The number of samples to use to estimate
+      the optimal coefficient. These need to be new samples to ensure that the
+      objective is unbiased.
+
+  Returns:
+    A tuple of size two:
+
+    * A tuple of size `params`, each element is `num_samples x param.shape`
+      jacobian vector containing the estimates of the gradients obtained
+      for each sample.
+      The mean of this vector is the gradient wrt to parameters that can be
+      used for learning. The entire jacobian vector can be used to assess
+      estimator variance.
+    * The updated CV state.
+  """
+  control_variate = control_variate_from_function(function)
+  stochastic_cv, expected_value_cv, update_state_cv = control_variate
+  data_dim = jax.tree_util.tree_leaves(params)[0].shape[0]
+  if estimate_cv_coeffs:
+    cv_coeffs = estimate_control_variate_coefficients(
+        function, control_variate_from_function, grad_estimator, params,
+        dist_builder, rng, estimate_cv_coeffs_num_samples,
+        control_variate_state)
+  else:
+    cv_coeffs = [1.0] * len(params)
+
+  # \int \nabla_{\theta} {p(x; \theta)} (f(x) - h(x; \theta)) dx
+  function_jacobians = grad_estimator(
+      function, params, dist_builder, rng, num_samples)
+
+  # Chain rule since CVs can also depend on parameters - for example, for the
+  # pathwise gradient estimator they have in order to have an effect on
+  # gradient.
+  # The rng has to be the same as passed to the grad_estimator above so that we
+  # obtain the same samples.
+  samples = dist_builder(*params).sample((num_samples,), seed=rng)
+  # If the CV has state, update it.
+  control_variate_state = update_state_cv(
+      params, samples, control_variate_state)
+
+  def samples_fn(x):
+    return stochastic_cv(
+        jax.lax.stop_gradient(params), x, control_variate_state)
+
+  cv_jacobians = grad_estimator(
+      samples_fn, params, dist_builder, rng, num_samples)
+
+  # The gradients of the stochastic covariate with respect to the parameters.
+  def param_fn(x):
+    return jnp.mean(_map(
+        stochastic_cv, x,
+        jax.lax.stop_gradient(samples), control_variate_state))
+
+  # [E_{p(x; \theta)} \nabla_{\theta} h(x; \theta)
+  cv_param_grads = jax.grad(param_fn)(params)
+  # The gradients of the closed form expectation of the control variate
+  # with respect to the parameters: # \nabla_{\theta} E_{p(x; \theta)}].
+  expected_value_grads = jax.grad(
+      lambda x: expected_value_cv(x, control_variate_state))(params)
+
+  jacobians = []
+  for param_index, param in enumerate(jax.tree_util.tree_leaves(params)):
+    chex.assert_shape(function_jacobians[param_index], (num_samples, data_dim))
+    chex.assert_shape(cv_jacobians[param_index], (num_samples, data_dim))
+    chex.assert_shape(cv_param_grads[param_index], (data_dim,))
+    chex.assert_shape(expected_value_grads[param_index], (data_dim,))
+
+    cv_coeff = cv_coeffs[param_index]
+    # \int \nabla_{\theta} {p(x; \theta)} (f(x) - h(x; \theta)) dx
+    param_jacobians = function_jacobians[param_index]
+    param_jacobians -= cv_coeff * cv_jacobians[param_index]
+    # - [E_{p(x; \theta)} \nabla_{\theta} h(x; \theta)
+    param_jacobians -= cv_coeff * cv_param_grads[param_index]
+    # \nabla_{\theta} E_{p(x; \theta)}]
+    param_jacobians += cv_coeff * expected_value_grads[param_index]
+
+    chex.assert_shape(param_jacobians, (num_samples,) + param.shape)
+    jacobians.append(param_jacobians)
+
+  return jacobians, control_variate_state
+
+
+def estimate_control_variate_coefficients(
+    function: Callable[[chex.Array], float],
+    control_variate_from_function: Callable[
+        [Callable[[chex.Array], float]], ControlVariate
+    ],
+    grad_estimator: Callable[..., jnp.ndarray],
+    params: base.Params,
+    dist_builder: Callable[..., Any],
+    rng: chex.PRNGKey,
+    num_samples: int,
+    control_variate_state: CvState = None,
+    eps: float = 1e-3,
+) -> Sequence[float]:
+  r"""Estimates the control variate coefficients for the given parameters.
+
+  For each variable `var_k`, the coefficient is given by:
+    \sum_k cov(df/d var_k, d cv/d var_k) / (\sum var(d cv/d var_k) + eps)
+
+  Where var_k is the k'th element of the parameters in `params`.
+  The covariance and variance calculations are done from samples obtained
+  from the distribution obtained by calling `dist_builder` on the input
+  `params`.
+
+  This function does not update the state of the control variate.
+
+  Args:
+    function: Function f(x) for which to estimate grads_{params} E_dist f(x).
+      The function takes in one argument (a sample from the distribution) and
+      returns a floating point value.
+    control_variate_from_function: The control variate to use to reduce
+      variance. See `control_delta_method` and `moving_avg_baseline` examples.
+    grad_estimator: The gradient estimator to be used to compute the gradients.
+      Note that not all control variates will reduce variance for all
+      estimators. For example, the `moving_avg_baseline` will make no difference
+      to the measure valued or pathwise estimators.
+    params: A tuple of jnp arrays.
+      The parameters for which to construct the distribution and for which we
+      want to compute the jacobians.
+    dist_builder: a constructor which builds a distribution given the input
+      parameters specified by params. `dist_builder(params)` should return a
+      valid distribution.
+    rng: a PRNGKey key.
+    num_samples: Int, the number of samples used to compute the grads.
+    control_variate_state: The control variate state. This is used for control
+      variates which keep states (such as the moving average baselines).
+    eps: A small constant used to avoid numerical issues. Float.
+
+  Returns:
+    A list of control variate coefficients (each a scalar), for each parameter
+    in `params`.
+  """
+  # Resample to avoid biased gradients.
+  cv_rng, _ = jax.random.split(rng)
+  del rng  # Avoid using rng in this function.
+  stochastic_cv, _, _ = control_variate_from_function(function)
+
+  # Samples have to be the same so we use the same rng.
+  cv_jacobians = grad_estimator(
+      lambda x: stochastic_cv(params, x, control_variate_state),
+      params, dist_builder, cv_rng, num_samples)
+  function_jacobians = grad_estimator(
+      function, params, dist_builder, cv_rng, num_samples)
+
+  def compute_coeff(param_cv_jacs, param_f_jacs):
+    assert param_f_jacs.ndim == 2
+    assert param_cv_jacs.ndim == 2
+
+    mean_f = jnp.mean(param_f_jacs, axis=0)
+    mean_cv = jnp.mean(param_cv_jacs, axis=0)
+
+    cov = jnp.mean((param_f_jacs - mean_f) * (param_cv_jacs - mean_cv), axis=0)
+
+    assert cov.ndim == 1
+
+    # Compute the coefficients which minimize variance.
+    # Since we want to minimize the variances across parameter dimensions,
+    # the optimal coefficients are given by the sum of covariances per
+    # dimensions over the sum of variances per dimension.
+    cv_coeff = jnp.sum(cov) / (jnp.sum(jnp.var(param_cv_jacs, axis=0)) + eps)
+    return jax.lax.stop_gradient(cv_coeff)
+
+  return [compute_coeff(cv_jacobians[i], function_jacobians[i])
+          for i in range(len(params))]

testbed/google-deepmind__optax/optax/monte_carlo/control_variates_test.py

@@ -0,0 +1,597 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for `control_variates.py`."""
+
+from absl.testing import absltest
+from absl.testing import parameterized
+
+import chex
+import jax
+import jax.numpy as jnp
+import numpy as np
+
+from optax._src import utils
+from optax.monte_carlo import control_variates
+from optax.monte_carlo import stochastic_gradient_estimators as sge
+
+
+# Set seed for deterministic sampling.
+np.random.seed(42)
+
+
+def _assert_equal(actual, expected, rtol=1e-2, atol=1e-2):
+  """Asserts that arrays are equal."""
+  # Note: assert_allclose does not check shapes
+  chex.assert_equal_shape((actual, expected))
+
+  # Scalar.
+  if not actual.shape:
+    np.testing.assert_allclose(
+        np.asarray(actual), np.asarray(expected), rtol, atol)
+    return
+
+  # We get around the bug https://github.com/numpy/numpy/issues/13801
+  zero_indices = np.argwhere(expected == 0)
+  if not np.all(np.abs(actual[zero_indices]) <= atol):
+    raise AssertionError(f'Larger than {atol} diff in {actual[zero_indices]}')
+
+  non_zero_indices = np.argwhere(expected != 0)
+  np.testing.assert_allclose(
+      np.asarray(actual)[non_zero_indices],
+      expected[non_zero_indices], rtol, atol)
+
+
+def _map(cv, params, samples, state=None):
+  return jax.vmap(lambda x: cv(params, x, state))(samples)
+
+
+def _map_variant(variant):
+  return variant(_map, static_argnums=0)
+
+
+def _cv_jac_variant(variant):
+  return variant(
+      control_variates.control_variates_jacobians,
+      static_argnums=(0, 1, 2, 4, 6, 7, 8))
+
+
+class DeltaControlVariateTest(chex.TestCase):
+
+  @chex.all_variants
+  @parameterized.parameters([(1.0, 0.5)])
+  def testQuadraticFunction(self, effective_mean, effective_log_scale):
+    data_dims = 20
+    num_samples = 10**6
+    rng = jax.random.PRNGKey(1)
+
+    mean = effective_mean * jnp.ones(shape=(data_dims), dtype=jnp.float32)
+    log_scale = effective_log_scale * jnp.ones(
+        shape=(data_dims), dtype=jnp.float32)
+    params = [mean, log_scale]
+
+    dist = utils.multi_normal(*params)
+    dist_samples = dist.sample((num_samples,), rng)
+    function = lambda x: jnp.sum(x**2)
+
+    cv, expected_cv, _ = control_variates.control_delta_method(function)
+    avg_cv = jnp.mean(_map_variant(self.variant)(cv, params, dist_samples))
+    expected_cv_value = jnp.sum(dist_samples**2) / num_samples
+
+    # This should be an analytical computation, the result needs to be
+    # accurate.
+    _assert_equal(avg_cv, expected_cv_value, rtol=1e-1, atol=1e-3)
+    _assert_equal(expected_cv(params, None), expected_cv_value, rtol=0.02)
+
+  @chex.all_variants
+  @parameterized.parameters([(1.0, 1.0)])
+  def testPolinomialFunction(self, effective_mean, effective_log_scale):
+    data_dims = 10
+    num_samples = 10**3
+
+    mean = effective_mean * jnp.ones(shape=(data_dims), dtype=jnp.float32)
+    log_scale = effective_log_scale * jnp.ones(
+        shape=(data_dims), dtype=jnp.float32)
+    params = [mean, log_scale]
+
+    dist = utils.multi_normal(*params)
+    rng = jax.random.PRNGKey(1)
+    dist_samples = dist.sample((num_samples,), rng)
+    function = lambda x: jnp.sum(x**5)
+
+    cv, expected_cv, _ = control_variates.control_delta_method(function)
+    avg_cv = jnp.mean(_map_variant(self.variant)(cv, params, dist_samples))
+
+    # Check that the average value of the control variate is close to the
+    # expected value.
+    _assert_equal(avg_cv, expected_cv(params, None), rtol=1e-1, atol=1e-3)
+
+  @chex.all_variants
+  def testNonPolynomialFunction(self):
+    data_dims = 10
+    num_samples = 10**3
+
+    mean = jnp.ones(shape=(data_dims), dtype=jnp.float32)
+    log_scale = jnp.ones(shape=(data_dims), dtype=jnp.float32)
+    params = [mean, log_scale]
+
+    rng = jax.random.PRNGKey(1)
+    dist = utils.multi_normal(*params)
+    dist_samples = dist.sample((num_samples,), rng)
+    function = lambda x: jnp.sum(jnp.log(x**2))
+
+    cv, expected_cv, _ = control_variates.control_delta_method(function)
+    avg_cv = jnp.mean(_map_variant(self.variant)(cv, params, dist_samples))
+
+    # Check that the average value of the control variate is close to the
+    # expected value.
+    _assert_equal(avg_cv, expected_cv(params, None), rtol=1e-1, atol=1e-3)
+
+    # Second order expansion is log(\mu**2) + 1/2 * \sigma**2 (-2 / \mu**2)
+    expected_cv_val = - np.exp(1.) ** 2 * data_dims
+    _assert_equal(
+        expected_cv(params, None), expected_cv_val, rtol=1e-1, atol=1e-3)
+
+
+class MovingAverageBaselineTest(chex.TestCase):
+
+  @chex.all_variants
+  @parameterized.parameters(
+      [(1.0, 0.5, 0.9),
+       (1.0, 0.5, 0.99)])
+  def testLinearFunction(
+      self, effective_mean, effective_log_scale, decay):
+    weights = jnp.array([1., 2., 3.], dtype=jnp.float32)
+    num_samples = 10**4
+    data_dims = len(weights)
+
+    mean = effective_mean * jnp.ones(shape=(data_dims), dtype=jnp.float32)
+    log_scale = effective_log_scale * jnp.ones(
+        shape=(data_dims), dtype=jnp.float32)
+
+    params = [mean, log_scale]
+    function = lambda x: jnp.sum(weights * x)
+
+    rng = jax.random.PRNGKey(1)
+    dist = utils.multi_normal(*params)
+    dist_samples = dist.sample((num_samples,), rng)
+
+    cv, expected_cv, update_state = control_variates.moving_avg_baseline(
+        function, decay=decay, zero_debias=False,
+        use_decay_early_training_heuristic=False)
+
+    state_1 = jnp.array(1.)
+    avg_cv = jnp.mean(_map_variant(self.variant)(
+        cv, params, dist_samples, (state_1, 0)))
+    _assert_equal(avg_cv, state_1)
+    _assert_equal(expected_cv(params, (state_1, 0)), state_1)
+
+    state_2 = jnp.array(2.)
+    avg_cv = jnp.mean(
+        _map_variant(self.variant)(cv, params, dist_samples, (state_2, 0)))
+    _assert_equal(avg_cv, state_2)
+    _assert_equal(expected_cv(params, (state_2, 0)), state_2)
+
+    update_state_1 = update_state(params, dist_samples, (state_1, 0))[0]
+    _assert_equal(
+        update_state_1,
+        decay * state_1 + (1 - decay) * function(mean))
+
+    update_state_2 = update_state(params, dist_samples, (state_2, 0))[0]
+    _assert_equal(
+        update_state_2,
+        decay * state_2 + (1 - decay) * function(mean))
+
+  @chex.all_variants
+  @parameterized.parameters(
+      [(1.0, 0.5, 0.9),
+       (1.0, 0.5, 0.99)])
+  def testLinearFunctionWithHeuristic(
+      self, effective_mean, effective_log_scale, decay):
+    weights = jnp.array([1., 2., 3.], dtype=jnp.float32)
+    num_samples = 10**5
+    data_dims = len(weights)
+
+    mean = effective_mean * jnp.ones(shape=(data_dims), dtype=jnp.float32)
+    log_scale = effective_log_scale * jnp.ones(
+        shape=(data_dims), dtype=jnp.float32)
+
+    params = [mean, log_scale]
+    function = lambda x: jnp.sum(weights * x)
+
+    rng = jax.random.PRNGKey(1)
+    dist = utils.multi_normal(*params)
+    dist_samples = dist.sample((num_samples,), rng)
+
+    cv, expected_cv, update_state = control_variates.moving_avg_baseline(
+        function, decay=decay, zero_debias=False,
+        use_decay_early_training_heuristic=True)
+
+    state_1 = jnp.array(1.)
+    avg_cv = jnp.mean(_map_variant(self.variant)(
+        cv, params, dist_samples, (state_1, 0)))
+    _assert_equal(avg_cv, state_1)
+    _assert_equal(expected_cv(params, (state_1, 0)), state_1)
+
+    state_2 = jnp.array(2.)
+    avg_cv = jnp.mean(
+        _map_variant(self.variant)(cv, params, dist_samples, (state_2, 0)))
+    _assert_equal(avg_cv, state_2)
+    _assert_equal(expected_cv(params, (state_2, 0)), state_2)
+
+    first_step_decay = 0.1
+    update_state_1 = update_state(params, dist_samples, (state_1, 0))[0]
+    _assert_equal(
+        update_state_1,
+        first_step_decay * state_1 + (1 - first_step_decay) * function(mean))
+
+    second_step_decay = 2. / 11
+    update_state_2 = update_state(params, dist_samples, (state_2, 1))[0]
+    _assert_equal(
+        update_state_2,
+        second_step_decay * state_2 + (1 - second_step_decay) * function(mean))
+
+  @parameterized.parameters(
+      [(1.0, 0.5, 0.9),
+       (1.0, 0.5, 0.99)])
+  def testLinearFunctionZeroDebias(
+      self, effective_mean, effective_log_scale, decay):
+    weights = jnp.array([1., 2., 3.], dtype=jnp.float32)
+    num_samples = 10**5
+    data_dims = len(weights)
+
+    mean = effective_mean * jnp.ones(shape=(data_dims), dtype=jnp.float32)
+    log_scale = effective_log_scale * jnp.ones(
+        shape=(data_dims), dtype=jnp.float32)
+
+    params = [mean, log_scale]
+    function = lambda x: jnp.sum(weights * x)
+
+    rng = jax.random.PRNGKey(1)
+    dist = utils.multi_normal(*params)
+    dist_samples = dist.sample((num_samples,), rng)
+
+    update_state = control_variates.moving_avg_baseline(
+        function, decay=decay, zero_debias=False,
+        use_decay_early_training_heuristic=False)[-1]
+
+    update_state_zero_debias = control_variates.moving_avg_baseline(
+        function, decay=decay, zero_debias=True,
+        use_decay_early_training_heuristic=False)[-1]
+
+    updated_state = update_state(params, dist_samples, (jnp.array(0.), 0))[0]
+    _assert_equal(updated_state, (1 - decay) * function(mean))
+
+    updated_state_zero_debias = update_state_zero_debias(
+        params, dist_samples, (jnp.array(0.), 0))[0]
+    _assert_equal(
+        updated_state_zero_debias, function(mean))
+
+
+class DeltaMethodAnalyticalExpectedGrads(chex.TestCase):
+  """Tests for grads approximations."""
+
+  @chex.all_variants
+  @parameterized.named_parameters(
+      chex.params_product([
+          ('_score_function_jacobians', 1.0, 1.0, sge.score_function_jacobians),
+          ('_pathwise_jacobians', 1.0, 1.0, sge.pathwise_jacobians),
+          ('_measure_valued_jacobians', 1.0, 1.0, sge.measure_valued_jacobians),
+      ], [
+          ('estimate_cv_coeffs', True),
+          ('no_estimate_cv_coeffs', False),
+      ],
+                          named=True))
+  def testQuadraticFunction(self, effective_mean, effective_log_scale,
+                            grad_estimator, estimate_cv_coeffs):
+    data_dims = 3
+    num_samples = 10**3
+
+    mean = effective_mean * jnp.ones(shape=(data_dims), dtype=jnp.float32)
+    log_scale = effective_log_scale * jnp.ones(
+        shape=(data_dims), dtype=jnp.float32)
+
+    params = [mean, log_scale]
+    function = lambda x: jnp.sum(x**2)
+    rng = jax.random.PRNGKey(1)
+
+    jacobians = _cv_jac_variant(self.variant)(
+        function,
+        control_variates.control_delta_method,
+        grad_estimator,
+        params,
+        utils.multi_normal,  # dist_builder
+        rng,
+        num_samples,
+        None,  # No cv state.
+        estimate_cv_coeffs)[0]
+
+    expected_mean_grads = 2 * effective_mean * np.ones(
+        data_dims, dtype=np.float32)
+    expected_log_scale_grads = 2 * np.exp(2 * effective_log_scale) * np.ones(
+        data_dims, dtype=np.float32)
+
+    mean_jacobians = jacobians[0]
+    chex.assert_shape(mean_jacobians, (num_samples, data_dims))
+    mean_grads_from_jacobian = jnp.mean(mean_jacobians, axis=0)
+
+    log_scale_jacobians = jacobians[1]
+    chex.assert_shape(log_scale_jacobians, (num_samples, data_dims))
+    log_scale_grads_from_jacobian = jnp.mean(log_scale_jacobians, axis=0)
+
+    _assert_equal(mean_grads_from_jacobian, expected_mean_grads,
+                  rtol=1e-1, atol=1e-3)
+    _assert_equal(log_scale_grads_from_jacobian, expected_log_scale_grads,
+                  rtol=1e-1, atol=1e-3)
+
+  @chex.all_variants
+  @parameterized.named_parameters(
+      chex.params_product([
+          ('_score_function_jacobians', 1.0, 1.0, sge.score_function_jacobians),
+          ('_pathwise_jacobians', 1.0, 1.0, sge.pathwise_jacobians),
+          ('_measure_valued_jacobians', 1.0, 1.0, sge.measure_valued_jacobians),
+      ], [
+          ('estimate_cv_coeffs', True),
+          ('no_estimate_cv_coeffs', False),
+      ],
+                          named=True))
+  def testCubicFunction(
+      self, effective_mean, effective_log_scale, grad_estimator,
+      estimate_cv_coeffs):
+    data_dims = 1
+    num_samples = 10**5
+
+    mean = effective_mean * jnp.ones(shape=(data_dims), dtype=jnp.float32)
+    log_scale = effective_log_scale * jnp.ones(
+        shape=(data_dims), dtype=jnp.float32)
+
+    params = [mean, log_scale]
+    function = lambda x: jnp.sum(x**3)
+    rng = jax.random.PRNGKey(1)
+
+    jacobians = _cv_jac_variant(self.variant)(
+        function,
+        control_variates.control_delta_method,
+        grad_estimator,
+        params,
+        utils.multi_normal,
+        rng,
+        num_samples,
+        None,  # No cv state.
+        estimate_cv_coeffs)[0]
+
+    # The third order uncentered moment of the Gaussian distribution is
+    # mu**3 + 2 mu * sigma **2. We use that to compute the expected value
+    # of the gradients. Note: for the log scale we need use the chain rule.
+    expected_mean_grads = (
+        3 * effective_mean**2 + 3 * np.exp(effective_log_scale)**2)
+    expected_mean_grads *= np.ones(data_dims, dtype=np.float32)
+    expected_log_scale_grads = (
+        6 * effective_mean * np.exp(effective_log_scale) ** 2)
+    expected_log_scale_grads *= np.ones(data_dims, dtype=np.float32)
+
+    mean_jacobians = jacobians[0]
+    chex.assert_shape(mean_jacobians, (num_samples, data_dims))
+    mean_grads_from_jacobian = jnp.mean(mean_jacobians, axis=0)
+
+    log_scale_jacobians = jacobians[1]
+    chex.assert_shape(log_scale_jacobians, (num_samples, data_dims))
+    log_scale_grads_from_jacobian = jnp.mean(log_scale_jacobians, axis=0)
+
+    _assert_equal(mean_grads_from_jacobian, expected_mean_grads,
+                  rtol=1e-1, atol=1e-3)
+
+    _assert_equal(log_scale_grads_from_jacobian, expected_log_scale_grads,
+                  rtol=1e-1, atol=1e-3)
+
+  @chex.all_variants
+  @parameterized.named_parameters(
+      chex.params_product([
+          ('_score_function_jacobians', 1.0, 1.0, sge.score_function_jacobians),
+          ('_pathwise_jacobians', 1.0, 1.0, sge.pathwise_jacobians),
+          ('_measure_valued_jacobians', 1.0, 1.0, sge.measure_valued_jacobians),
+      ], [
+          ('estimate_cv_coeffs', True),
+          ('no_estimate_cv_coeffs', False),
+      ],
+                          named=True))
+  def testForthPowerFunction(
+      self, effective_mean, effective_log_scale, grad_estimator,
+      estimate_cv_coeffs):
+    data_dims = 1
+    num_samples = 10**5
+
+    mean = effective_mean * jnp.ones(shape=(data_dims), dtype=jnp.float32)
+    log_scale = effective_log_scale * jnp.ones(
+        shape=(data_dims), dtype=jnp.float32)
+
+    params = [mean, log_scale]
+    function = lambda x: jnp.sum(x**4)
+    rng = jax.random.PRNGKey(1)
+
+    jacobians = _cv_jac_variant(self.variant)(
+        function,
+        control_variates.control_delta_method,
+        grad_estimator,
+        params,
+        utils.multi_normal,
+        rng,
+        num_samples,
+        None,  # No cv state
+        estimate_cv_coeffs)[0]
+    # The third order uncentered moment of the Gaussian distribution is
+    # mu**4 + 6 mu **2 sigma **2 + 3 sigma**4. We use that to compute the
+    # expected value of the gradients.
+    # Note: for the log scale we need use the chain rule.
+    expected_mean_grads = (
+        3 * effective_mean**3
+        + 12 * effective_mean * np.exp(effective_log_scale)**2)
+    expected_mean_grads *= np.ones(data_dims, dtype=np.float32)
+    expected_log_scale_grads = 12 * (
+        effective_mean**2 * np.exp(effective_log_scale) +
+        np.exp(effective_log_scale) ** 3) * np.exp(effective_log_scale)
+    expected_log_scale_grads *= np.ones(data_dims, dtype=np.float32)
+
+    mean_jacobians = jacobians[0]
+    chex.assert_shape(mean_jacobians, (num_samples, data_dims))
+    mean_grads_from_jacobian = jnp.mean(mean_jacobians, axis=0)
+
+    log_scale_jacobians = jacobians[1]
+    chex.assert_shape(log_scale_jacobians, (num_samples, data_dims))
+    log_scale_grads_from_jacobian = jnp.mean(log_scale_jacobians, axis=0)
+
+    _assert_equal(mean_grads_from_jacobian, expected_mean_grads,
+                  rtol=1e-1, atol=1e-3)
+
+    _assert_equal(log_scale_grads_from_jacobian, expected_log_scale_grads,
+                  rtol=1e-1, atol=1e-3)
+
+
+class ConsistencyWithStandardEstimators(chex.TestCase):
+  """Tests for consistency between estimators."""
+
+  @chex.all_variants
+  @parameterized.named_parameters(
+      chex.params_product([
+          ('_score_function_jacobians', 1, 1, sge.score_function_jacobians),
+          ('_pathwise_jacobians', 1, 1, sge.pathwise_jacobians),
+          ('_measure_valued_jacobians', 1, 1, sge.measure_valued_jacobians),
+      ], [
+          (
+              'control_delta_method',
+              10**5,
+              control_variates.control_delta_method
+          ),
+          ('moving_avg_baseline', 10**6, control_variates.moving_avg_baseline),
+      ],
+                          named=True))
+  def testWeightedLinearFunction(self, effective_mean, effective_log_scale,
+                                 grad_estimator, num_samples,
+                                 control_variate_from_function):
+    """Check that the gradients are consistent between estimators."""
+    weights = jnp.array([1., 2., 3.], dtype=jnp.float32)
+    data_dims = len(weights)
+
+    mean = effective_mean * jnp.ones(shape=(data_dims), dtype=jnp.float32)
+    log_scale = effective_log_scale * jnp.ones(
+        shape=(data_dims), dtype=jnp.float32)
+
+    params = [mean, log_scale]
+    function = lambda x: jnp.sum(weights * x)
+    rng = jax.random.PRNGKey(1)
+    cv_rng, ge_rng = jax.random.split(rng)
+
+    jacobians = _cv_jac_variant(self.variant)(
+        function,
+        control_variate_from_function,
+        grad_estimator,
+        params,
+        utils.multi_normal,  # dist_builder
+        cv_rng,  # rng
+        num_samples,
+        (0., 0),  # control_variate_state
+        False)[0]
+
+    mean_jacobians = jacobians[0]
+    chex.assert_shape(mean_jacobians, (num_samples, data_dims))
+    mean_grads = jnp.mean(mean_jacobians, axis=0)
+
+    log_scale_jacobians = jacobians[1]
+    chex.assert_shape(log_scale_jacobians, (num_samples, data_dims))
+    log_scale_grads = jnp.mean(log_scale_jacobians, axis=0)
+
+    # We use a different random number generator for the gradient estimator
+    # without the control variate.
+    no_cv_jacobians = grad_estimator(
+        function, [mean, log_scale],
+        utils.multi_normal, ge_rng, num_samples=num_samples)
+
+    no_cv_mean_jacobians = no_cv_jacobians[0]
+    chex.assert_shape(no_cv_mean_jacobians, (num_samples, data_dims))
+    no_cv_mean_grads = jnp.mean(no_cv_mean_jacobians, axis=0)
+
+    no_cv_log_scale_jacobians = no_cv_jacobians[1]
+    chex.assert_shape(no_cv_log_scale_jacobians, (num_samples, data_dims))
+    no_cv_log_scale_grads = jnp.mean(no_cv_log_scale_jacobians, axis=0)
+
+    _assert_equal(mean_grads, no_cv_mean_grads, rtol=1e-1, atol=5e-2)
+    _assert_equal(log_scale_grads, no_cv_log_scale_grads, rtol=1, atol=5e-2)
+
+  @chex.all_variants
+  @parameterized.named_parameters(
+      chex.params_product([
+          ('_score_function_jacobians', 1, 1, sge.score_function_jacobians,
+           10**5),
+          ('_pathwise_jacobians', 1, 1, sge.pathwise_jacobians, 10**5),
+          ('_measure_valued_jacobians', 1, 1, sge.measure_valued_jacobians,
+           10**5),
+      ], [
+          ('control_delta_method', control_variates.control_delta_method),
+          ('moving_avg_baseline', control_variates.moving_avg_baseline),
+      ],
+                          named=True))
+  def testNonPolynomialFunction(
+      self, effective_mean, effective_log_scale,
+      grad_estimator, num_samples, control_variate_from_function):
+    """Check that the gradients are consistent between estimators."""
+    data_dims = 3
+
+    mean = effective_mean * jnp.ones(shape=(data_dims), dtype=jnp.float32)
+    log_scale = effective_log_scale * jnp.ones(
+        shape=(data_dims), dtype=jnp.float32)
+
+    params = [mean, log_scale]
+    function = lambda x: jnp.log(jnp.sum(x**2))
+    rng = jax.random.PRNGKey(1)
+    cv_rng, ge_rng = jax.random.split(rng)
+
+    jacobians = _cv_jac_variant(self.variant)(
+        function,
+        control_variate_from_function,
+        grad_estimator,
+        params,
+        utils.multi_normal,
+        cv_rng,
+        num_samples,
+        (0., 0),  # control_variate_state
+        False)[0]
+
+    mean_jacobians = jacobians[0]
+    chex.assert_shape(mean_jacobians, (num_samples, data_dims))
+    mean_grads = jnp.mean(mean_jacobians, axis=0)
+
+    log_scale_jacobians = jacobians[1]
+    chex.assert_shape(log_scale_jacobians, (num_samples, data_dims))
+    log_scale_grads = jnp.mean(log_scale_jacobians, axis=0)
+
+    # We use a different random number generator for the gradient estimator
+    # without the control variate.
+    no_cv_jacobians = grad_estimator(
+        function, [mean, log_scale],
+        utils.multi_normal, ge_rng, num_samples=num_samples)
+
+    no_cv_mean_jacobians = no_cv_jacobians[0]
+    chex.assert_shape(no_cv_mean_jacobians, (num_samples, data_dims))
+    no_cv_mean_grads = jnp.mean(no_cv_mean_jacobians, axis=0)
+
+    no_cv_log_scale_jacobians = no_cv_jacobians[1]
+    chex.assert_shape(no_cv_log_scale_jacobians, (num_samples, data_dims))
+    no_cv_log_scale_grads = jnp.mean(no_cv_log_scale_jacobians, axis=0)
+
+    _assert_equal(mean_grads, no_cv_mean_grads, rtol=1e-1, atol=5e-2)
+    _assert_equal(log_scale_grads, no_cv_log_scale_grads, rtol=1e-1, atol=5e-2)
+
+
+if __name__ == '__main__':
+  absltest.main()

testbed/google-deepmind__optax/optax/monte_carlo/stochastic_gradient_estimators.py

@@ -0,0 +1,317 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+r"""Stochastic Monte Carlo gradient estimators.
+
+Utility functions to approximate gradients of the form using Monte Carlo
+estimation:
+  \nabla_{\theta} E_{p(x; \theta)} f(x)
+
+Here f is assumed to have no dependence on the parameters theta - if f has
+dependence on theta, the functions below need to be called with `stop_grad(f)`
+and the chain rule needs to be applied outside these functions in order
+to obtain unbiased gradient.
+
+For more details, see:
+S. Mohamed, M. Rosca, M. Figurnov, A Mnih.
+  Monte Carlo Gradient Estimation in Machine Learning. JMLR, 2020.
+"""
+
+import math
+from typing import Any, Callable, Sequence
+
+import chex
+import jax
+import jax.numpy as jnp
+import numpy as np
+from optax._src import base
+from optax._src import utils
+
+
+def score_function_jacobians(
+    function: Callable[[chex.Array], float],
+    params: base.Params,
+    dist_builder: Callable[..., Any],
+    rng: chex.PRNGKey,
+    num_samples: int) -> Sequence[chex.Array]:
+  r"""Score function gradient estimation.
+
+  Approximates:
+     \nabla_{\theta} E_{p(x; \theta)} f(x)
+  With:
+    E_{p(x; \theta)} f(x) \nabla_{\theta} \log p(x; \theta)
+
+  Requires: p to be differentiable wrt to theta. Applicable to both continuous
+    and discrete random variables. No requirements on f.
+
+  Args:
+    function: Function f(x) for which to estimate grads_{params} E_dist f(x).
+      The function takes in one argument (a sample from the distribution) and
+      returns a floating point value.
+    params: A tuple of jnp arrays.
+      The parameters for which to construct the distribution.
+    dist_builder: a constructor which builds a distribution given the input
+      parameters specified by params. `dist_builder(params)` should return a
+      valid distribution.
+    rng: a PRNGKey key.
+    num_samples: Int, the number of samples used to compute the grads.
+
+  Returns:
+    A tuple of size `params`, each element is `num_samples x param.shape`
+      jacobian vector containing the estimates of the gradients obtained for
+      each sample.
+    The mean of this vector is the gradient wrt to parameters that can be used
+      for learning. The entire jacobian vector can be used to assess estimator
+      variance.
+  """
+  def surrogate(params):
+    dist = dist_builder(*params)
+    one_sample_surrogate_fn = lambda x: function(x) * dist.log_prob(x)
+    samples = jax.lax.stop_gradient(dist.sample((num_samples,), seed=rng))
+    # We vmap the function application over samples - this ensures that the
+    # function we use does not have to be vectorized itself.
+    return jax.vmap(one_sample_surrogate_fn)(samples)
+
+  return jax.jacfwd(surrogate)(params)
+
+
+def pathwise_jacobians(
+    function: Callable[[chex.Array], float],
+    params: base.Params,
+    dist_builder: Callable[..., Any],
+    rng: chex.PRNGKey,
+    num_samples: int) -> Sequence[chex.Array]:
+  r"""Pathwise gradient estimation.
+
+  Approximates:
+     \nabla_{\theta} E_{p(x; \theta)} f(x)
+  With:
+    E_{p(\epsilon)} \nabla_{\theta} f(g(\epsilon, \theta))
+      where x = g(\epsilon, \theta). g depends on the distribution p.
+
+  Requires: p to be reparametrizable and the reparametrization to be implemented
+    in tensorflow_probability. Applicable to continuous random variables.
+    f needs to be differentiable.
+
+  Args:
+    function: Function f(x) for which to estimate grads_{params} E_dist f(x).
+      The function takes in one argument (a sample from the distribution) and
+      returns a floating point value.
+    params: A tuple of jnp arrays.
+      The parameters for which to construct the distribution.
+    dist_builder: a constructor which builds a distribution given the input
+      parameters specified by params. `dist_builder(params)` should return a
+      valid distribution.
+    rng: a PRNGKey key.
+    num_samples: Int, the number of samples used to compute the grads.
+
+  Returns:
+    A tuple of size `params`, each element is `num_samples x param.shape`
+      jacobian vector containing the estimates of the gradients obtained for
+      each sample.
+    The mean of this vector is the gradient wrt to parameters that can be used
+      for learning. The entire jacobian vector can be used to assess estimator
+      variance.
+  """
+  def surrogate(params):
+    # We vmap the function application over samples - this ensures that the
+    # function we use does not have to be vectorized itself.
+    dist = dist_builder(*params)
+    return jax.vmap(function)(dist.sample((num_samples,), seed=rng))
+
+  return jax.jacfwd(surrogate)(params)
+
+
+def measure_valued_jacobians(
+    function: Callable[[chex.Array], float],
+    params: base.Params,
+    dist_builder: Callable[..., Any],
+    rng: chex.PRNGKey,
+    num_samples: int,
+    coupling: bool = True) -> Sequence[chex.Array]:
+  r"""Measure valued gradient estimation.
+
+  Approximates:
+     \nabla_{\theta} E_{p(x; \theta)} f(x)
+  With:
+    1./ c (E_{p1(x; \theta)} f(x) - E_{p2(x; \theta)} f(x)) where p1 and p2 are
+    measures which depend on p.
+
+  Currently only supports computing gradients of expectations of Gaussian RVs.
+
+  Args:
+    function: Function f(x) for which to estimate grads_{params} E_dist f(x).
+      The function takes in one argument (a sample from the distribution) and
+      returns a floating point value.
+    params: A tuple of jnp arrays.
+      The parameters for which to construct the distribution.
+    dist_builder: a constructor which builds a distribution given the input
+      parameters specified by params. `dist_builder(params)` should return a
+      valid distribution.
+    rng: a PRNGKey key.
+    num_samples: Int, the number of samples used to compute the grads.
+    coupling: A boolean. Whether or not to use coupling for the positive and
+      negative samples. Recommended: True, as this reduces variance.
+
+  Returns:
+    A tuple of size `params`, each element is `num_samples x param.shape`
+      jacobian vector containing the estimates of the gradients obtained for
+      each sample.
+    The mean of this vector is the gradient wrt to parameters that can be used
+      for learning. The entire jacobian vector can be used to assess estimator
+      variance.
+  """
+  if dist_builder is not utils.multi_normal:
+    raise ValueError(
+        'Unsupported distribution builder for measure_valued_jacobians!')
+  dist = dist_builder(*params)
+  # Need to apply chain rule for log scale grad (instead of scale grad).
+  return [
+      measure_valued_estimation_mean(
+          function, dist, rng, num_samples, coupling=coupling),
+      jnp.exp(dist.log_scale) * measure_valued_estimation_std(
+          function, dist, rng, num_samples, coupling=coupling)]
+
+
+def measure_valued_estimation_mean(
+    function: Callable[[chex.Array], float],
+    dist: Any,
+    rng: chex.PRNGKey,
+    num_samples: int,
+    coupling: bool = True) -> chex.Array:
+  """Measure valued grads of a Gaussian expectation of `function` wrt the mean.
+
+  Args:
+    function: Function f(x) for which to estimate grads_{mean} E_dist f(x).
+      The function takes in one argument (a sample from the distribution) and
+      returns a floating point value.
+    dist: a distribution on which we can call `sample`.
+    rng: a PRNGKey key.
+    num_samples: Int, the number of samples used to compute the grads.
+    coupling: A boolean. Whether or not to use coupling for the positive and
+      negative samples. Recommended: True, as this reduces variance.
+
+  Returns:
+    A `num_samples x D` vector containing the estimates of the gradients
+    obtained for each sample. The mean of this vector can be used to update
+    the mean parameter. The entire vector can be used to assess estimator
+    variance.
+  """
+  mean, log_std = dist.params
+  std = jnp.exp(log_std)
+
+  dist_samples = dist.sample((num_samples,), seed=rng)
+
+  pos_rng, neg_rng = jax.random.split(rng)
+  pos_sample = jax.random.weibull_min(
+      pos_rng, scale=math.sqrt(2.), concentration=2., shape=dist_samples.shape)
+
+  if coupling:
+    neg_sample = pos_sample
+  else:
+    neg_sample = jax.random.weibull_min(
+        neg_rng,
+        scale=math.sqrt(2.),
+        concentration=2.,
+        shape=dist_samples.shape)
+
+  # N x D
+  positive_diag = mean + std * pos_sample
+  # N x D
+  negative_diag = mean - std * neg_sample
+
+  # NOTE: you can sample base samples here if you use the same rng
+  # Duplicate the D dimension - N x D x D.
+  base_dist_samples = utils.tile_second_to_last_dim(dist_samples)
+  positive = utils.set_diags(base_dist_samples, positive_diag)
+  negative = utils.set_diags(base_dist_samples, negative_diag)
+
+  c = np.sqrt(2 * np.pi) * std  # D
+  # Apply function. We apply the function to each element of N x D x D.
+  # We apply a function that takes a sample and returns one number, so the
+  # output will be N x D (which is what we want, batch by dimension).
+  # We apply a function in parallel to the batch.
+  # Broadcast the division.
+  vmaped_function = jax.vmap(jax.vmap(function, 1, 0))
+  grads = (vmaped_function(positive) - vmaped_function(negative)) / c
+
+  chex.assert_shape(grads, (num_samples,) + std.shape)
+  return grads
+
+
+def measure_valued_estimation_std(
+    function: Callable[[chex.Array], float],
+    dist: Any,
+    rng: chex.PRNGKey,
+    num_samples: int,
+    coupling: bool = True) -> chex.Array:
+  """Measure valued grads of a Gaussian expectation of `function` wrt the std.
+
+  Args:
+    function: Function f(x) for which to estimate grads_{std} E_dist f(x).
+      The function takes in one argument (a sample from the distribution) and
+      returns a floating point value.
+    dist: a distribution on which we can call `sample`.
+    rng: a PRNGKey key.
+    num_samples: Int, the number of samples used to compute the grads.
+    coupling: A boolean. Whether or not to use coupling for the positive and
+      negative samples. Recommended: True, as this reduces variance.
+
+  Returns:
+    A `num_samples x D` vector containing the estimates of the gradients
+    obtained for each sample. The mean of this vector can be used to update
+    the scale parameter. The entire vector can be used to assess estimator
+    variance.
+  """
+  mean, log_std = dist.params
+  std = jnp.exp(log_std)
+
+  dist_samples = dist.sample((num_samples,), seed=rng)
+
+  pos_rng, neg_rng = jax.random.split(rng)
+
+  # The only difference between mean and std gradients is what we sample.
+  pos_sample = jax.random.double_sided_maxwell(
+      pos_rng, loc=0.0, scale=1.0, shape=dist_samples.shape)
+  if coupling:
+    unif_rvs = jax.random.uniform(neg_rng, dist_samples.shape)
+    neg_sample = unif_rvs * pos_sample
+  else:
+    neg_sample = jax.random.normal(neg_rng, dist_samples.shape)
+
+  # Both need to be positive in the case of the scale.
+  # N x D
+  positive_diag = mean + std * pos_sample
+  # N x D
+  negative_diag = mean + std * neg_sample
+
+  # NOTE: you can sample base samples here if you use the same rng
+  # Duplicate the D dimension - N x D x D.
+  base_dist_samples = utils.tile_second_to_last_dim(dist_samples)
+  positive = utils.set_diags(base_dist_samples, positive_diag)
+  negative = utils.set_diags(base_dist_samples, negative_diag)
+
+  # Different C for the scale
+  c = std  # D
+  # Apply function. We apply the function to each element of N x D x D.
+  # We apply a function that takes a sample and returns one number, so the
+  # output will be N x D (which is what we want, batch by dimension).
+  # We apply a function in parallel to the batch.
+  # Broadcast the division.
+  vmaped_function = jax.vmap(jax.vmap(function, 1, 0))
+  grads = (vmaped_function(positive) - vmaped_function(negative)) / c
+
+  chex.assert_shape(grads, (num_samples,) + std.shape)
+  return grads
+

testbed/google-deepmind__optax/optax/monte_carlo/stochastic_gradient_estimators_test.py

@@ -0,0 +1,371 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for `stochastic_gradient_estimators.py`."""
+
+from absl.testing import absltest
+from absl.testing import parameterized
+
+import chex
+import jax
+import jax.numpy as jnp
+import numpy as np
+
+from optax._src import utils
+from optax.monte_carlo import stochastic_gradient_estimators as sge
+
+
+# Set seed for deterministic sampling.
+np.random.seed(42)
+
+
+_estimator_to_num_samples = {
+    sge.score_function_jacobians: 5 * 10**5,
+    sge.measure_valued_jacobians: 10**5,
+    sge.pathwise_jacobians: 5 * 10**4,
+}
+
+_weighted_estimator_to_num_samples = {
+    sge.score_function_jacobians: 5 * 10**6,
+    sge.measure_valued_jacobians: 5 * 10**5,
+    sge.pathwise_jacobians: 5 * 10**4,
+}
+
+
+def _ones(dims):
+  return jnp.ones(shape=(dims), dtype=jnp.float32)
+
+
+def _assert_equal(actual, expected, rtol=1e-2, atol=1e-2):
+  """Asserts that arrays are equal."""
+  # Note: assert_allclose does not check shapes
+  chex.assert_equal_shape((actual, expected))
+
+  # We get around the bug https://github.com/numpy/numpy/issues/13801
+  zero_indices = np.argwhere(expected == 0)
+  if not np.all(np.abs(actual[zero_indices]) <= atol):
+    raise AssertionError(f'Larger than {atol} diff in {actual[zero_indices]}')
+
+  non_zero_indices = np.argwhere(expected != 0)
+  np.testing.assert_allclose(
+      np.asarray(actual)[non_zero_indices],
+      expected[non_zero_indices], rtol, atol)
+
+
+def _estimator_variant(variant, estimator):
+  return variant(estimator, static_argnums=(0, 2, 4))
+
+
+def _measure_valued_variant(variant):
+  return variant(
+      sge.measure_valued_jacobians,
+      static_argnums=(0, 2, 4, 5))
+
+
+class GradientEstimatorsTest(chex.TestCase):
+
+  @chex.all_variants
+  @parameterized.named_parameters(
+      chex.params_product([
+          ('_score_function_jacobians', sge.score_function_jacobians),
+          ('_pathwise_jacobians', sge.pathwise_jacobians),
+          ('_measure_valued_jacobians', sge.measure_valued_jacobians),
+      ], [
+          ('0.1', 0.1),
+          ('0.5', 0.5),
+          ('0.9', 0.9),
+      ],
+                          named=True))
+  def testConstantFunction(self, estimator, constant):
+    data_dims = 3
+    num_samples = _estimator_to_num_samples[estimator]
+
+    effective_mean = 1.5
+    mean = effective_mean * _ones(data_dims)
+
+    effective_log_scale = 0.0
+    log_scale = effective_log_scale * _ones(data_dims)
+    rng = jax.random.PRNGKey(1)
+
+    jacobians = _estimator_variant(self.variant, estimator)(
+        lambda x: jnp.array(constant), [mean, log_scale],
+        utils.multi_normal, rng, num_samples)
+
+    # Average over the number of samples.
+    mean_jacobians = jacobians[0]
+    chex.assert_shape(mean_jacobians, (num_samples, data_dims))
+    mean_grads = np.mean(mean_jacobians, axis=0)
+    expected_mean_grads = np.zeros(data_dims, dtype=np.float32)
+
+    log_scale_jacobians = jacobians[1]
+    chex.assert_shape(log_scale_jacobians, (num_samples, data_dims))
+    log_scale_grads = np.mean(log_scale_jacobians, axis=0)
+    expected_log_scale_grads = np.zeros(data_dims, dtype=np.float32)
+
+    _assert_equal(mean_grads, expected_mean_grads, atol=5e-3)
+    _assert_equal(log_scale_grads, expected_log_scale_grads, atol=5e-3)
+
+  @chex.all_variants
+  @parameterized.named_parameters(
+      chex.params_product([
+          ('_score_function_jacobians', sge.score_function_jacobians),
+          ('_pathwise_jacobians', sge.pathwise_jacobians),
+          ('_measure_valued_jacobians', sge.measure_valued_jacobians),
+      ], [
+          ('0.5_-1.', 0.5, -1.),
+          ('0.7_0.0)', 0.7, 0.0),
+          ('0.8_0.1', 0.8, 0.1),
+      ],
+                          named=True))
+  def testLinearFunction(self, estimator, effective_mean, effective_log_scale):
+    data_dims = 3
+    num_samples = _estimator_to_num_samples[estimator]
+    rng = jax.random.PRNGKey(1)
+
+    mean = effective_mean * _ones(data_dims)
+    log_scale = effective_log_scale * _ones(data_dims)
+
+    jacobians = _estimator_variant(self.variant, estimator)(
+        np.sum, [mean, log_scale],
+        utils.multi_normal, rng, num_samples)
+
+    mean_jacobians = jacobians[0]
+    chex.assert_shape(mean_jacobians, (num_samples, data_dims))
+    mean_grads = np.mean(mean_jacobians, axis=0)
+    expected_mean_grads = np.ones(data_dims, dtype=np.float32)
+
+    log_scale_jacobians = jacobians[1]
+    chex.assert_shape(log_scale_jacobians, (num_samples, data_dims))
+    log_scale_grads = np.mean(log_scale_jacobians, axis=0)
+    expected_log_scale_grads = np.zeros(data_dims, dtype=np.float32)
+
+    _assert_equal(mean_grads, expected_mean_grads)
+    _assert_equal(log_scale_grads, expected_log_scale_grads)
+
+  @chex.all_variants
+  @parameterized.named_parameters(
+      chex.params_product([
+          ('_score_function_jacobians', sge.score_function_jacobians),
+          ('_pathwise_jacobians', sge.pathwise_jacobians),
+          ('_measure_valued_jacobians', sge.measure_valued_jacobians),
+      ], [
+          ('1.0_0.3', 1.0, 0.3),
+      ],
+                          named=True))
+  def testQuadraticFunction(
+      self, estimator, effective_mean, effective_log_scale):
+    data_dims = 3
+    num_samples = _estimator_to_num_samples[estimator]
+    rng = jax.random.PRNGKey(1)
+
+    mean = effective_mean * _ones(data_dims)
+    log_scale = effective_log_scale * _ones(data_dims)
+
+    jacobians = _estimator_variant(self.variant, estimator)(
+        lambda x: np.sum(x**2) / 2, [mean, log_scale],
+        utils.multi_normal, rng, num_samples)
+
+    mean_jacobians = jacobians[0]
+    chex.assert_shape(mean_jacobians, (num_samples, data_dims))
+    mean_grads = np.mean(mean_jacobians, axis=0)
+    expected_mean_grads = effective_mean * np.ones(
+        data_dims, dtype=np.float32)
+
+    log_scale_jacobians = jacobians[1]
+    chex.assert_shape(log_scale_jacobians, (num_samples, data_dims))
+    log_scale_grads = np.mean(log_scale_jacobians, axis=0)
+    expected_log_scale_grads = np.exp(2 * effective_log_scale) * np.ones(
+        data_dims, dtype=np.float32)
+
+    _assert_equal(mean_grads, expected_mean_grads, atol=5e-2)
+    _assert_equal(log_scale_grads, expected_log_scale_grads, atol=5e-2)
+
+  @chex.all_variants
+  @parameterized.named_parameters(
+      chex.params_product([
+          ('_score_function_jacobians', sge.score_function_jacobians),
+          ('_pathwise_jacobians', sge.pathwise_jacobians),
+          ('_measure_valued_jacobians', sge.measure_valued_jacobians),
+      ], [
+          ('case_1', [1.0, 2.0, 3.], [-1., 0.3, -2.], [1., 1., 1.]),
+          ('case_2', [1.0, 2.0, 3.], [-1., 0.3, -2.], [4., 2., 3.]),
+          ('case_3', [1.0, 2.0, 3.], [0.1, 0.2, 0.1], [10., 5., 1.]),
+      ],
+                          named=True))
+  def testWeightedLinear(
+      self, estimator, effective_mean, effective_log_scale, weights):
+    num_samples = _weighted_estimator_to_num_samples[estimator]
+    rng = jax.random.PRNGKey(1)
+
+    mean = jnp.array(effective_mean)
+    log_scale = jnp.array(effective_log_scale)
+    weights = jnp.array(weights)
+
+    data_dims = len(effective_mean)
+
+    function = lambda x: jnp.sum(x * weights)
+    jacobians = _estimator_variant(self.variant, estimator)(
+        function, [mean, log_scale],
+        utils.multi_normal, rng, num_samples)
+
+    mean_jacobians = jacobians[0]
+    chex.assert_shape(mean_jacobians, (num_samples, data_dims))
+    mean_grads = np.mean(mean_jacobians, axis=0)
+
+    log_scale_jacobians = jacobians[1]
+    chex.assert_shape(log_scale_jacobians, (num_samples, data_dims))
+    log_scale_grads = np.mean(log_scale_jacobians, axis=0)
+
+    expected_mean_grads = weights
+    expected_log_scale_grads = np.zeros(data_dims, dtype=np.float32)
+
+    _assert_equal(mean_grads, expected_mean_grads, atol=5e-2)
+    _assert_equal(log_scale_grads, expected_log_scale_grads, atol=5e-2)
+
+  @chex.all_variants
+  @parameterized.named_parameters(
+      chex.params_product([
+          ('_score_function_jacobians', sge.score_function_jacobians),
+          ('_pathwise_jacobians', sge.pathwise_jacobians),
+          ('_measure_valued_jacobians', sge.measure_valued_jacobians),
+      ], [
+          ('case_1', [1.0, 2.0, 3.], [-1., 0.3, -2.], [1., 1., 1.]),
+          ('case_2', [1.0, 2.0, 3.], [-1., 0.3, -2.], [4., 2., 3.]),
+          ('case_3', [1.0, 2.0, 3.], [0.1, 0.2, 0.1], [3., 5., 1.]),
+      ],
+                          named=True))
+  def testWeightedQuadratic(
+      self, estimator, effective_mean, effective_log_scale, weights):
+    num_samples = _weighted_estimator_to_num_samples[estimator]
+    rng = jax.random.PRNGKey(1)
+
+    mean = jnp.array(effective_mean, dtype=jnp.float32)
+    log_scale = jnp.array(effective_log_scale, dtype=jnp.float32)
+    weights = jnp.array(weights, dtype=jnp.float32)
+
+    data_dims = len(effective_mean)
+
+    function = lambda x: jnp.sum(x * weights) ** 2
+    jacobians = _estimator_variant(self.variant, estimator)(
+        function, [mean, log_scale],
+        utils.multi_normal, rng, num_samples)
+
+    mean_jacobians = jacobians[0]
+    chex.assert_shape(mean_jacobians, (num_samples, data_dims))
+    mean_grads = np.mean(mean_jacobians, axis=0)
+
+    log_scale_jacobians = jacobians[1]
+    chex.assert_shape(log_scale_jacobians, (num_samples, data_dims))
+    log_scale_grads = np.mean(log_scale_jacobians, axis=0)
+
+    expected_mean_grads = 2 * weights * np.sum(weights * mean)
+    effective_scale = np.exp(log_scale)
+    expected_scale_grads = 2 * weights ** 2 * effective_scale
+    expected_log_scale_grads = expected_scale_grads * effective_scale
+
+    _assert_equal(mean_grads, expected_mean_grads, atol=1e-1, rtol=1e-1)
+    _assert_equal(
+        log_scale_grads, expected_log_scale_grads, atol=1e-1, rtol=1e-1)
+
+  @chex.all_variants
+  @parameterized.named_parameters(
+      chex.params_product(
+          [
+              ('_sum_cos_x', [1.0], [1.0], lambda x: jnp.sum(jnp.cos(x))),
+              # Need to ensure that the mean is not too close to 0.
+              ('_sum_log_x', [10.0], [0.0], lambda x: jnp.sum(jnp.log(x))),
+              ('_sum_cos_2x', [1.0, 2.0], [1.0, -2
+                                          ], lambda x: jnp.sum(jnp.cos(2 * x))),
+              ('_cos_sum_2x', [1.0, 2.0], [1.0, -2
+                                          ], lambda x: jnp.cos(jnp.sum(2 * x))),
+          ],
+          [
+              ('coupling', True),
+              ('nocoupling', False),
+          ],
+          named=True))
+  def testNonPolynomialFunctionConsistencyWithPathwise(self, effective_mean,
+                                                       effective_log_scale,
+                                                       function, coupling):
+    num_samples = 10**5
+    rng = jax.random.PRNGKey(1)
+    measure_rng, pathwise_rng = jax.random.split(rng)
+
+    mean = jnp.array(effective_mean, dtype=jnp.float32)
+    log_scale = jnp.array(effective_log_scale, dtype=jnp.float32)
+    data_dims = len(effective_mean)
+
+    measure_valued_jacobians = _measure_valued_variant(self.variant)(
+        function, [mean, log_scale],
+        utils.multi_normal, measure_rng, num_samples, coupling)
+
+    measure_valued_mean_jacobians = measure_valued_jacobians[0]
+    chex.assert_shape(measure_valued_mean_jacobians, (num_samples, data_dims))
+    measure_valued_mean_grads = np.mean(measure_valued_mean_jacobians, axis=0)
+
+    measure_valued_log_scale_jacobians = measure_valued_jacobians[1]
+    chex.assert_shape(
+        measure_valued_log_scale_jacobians, (num_samples, data_dims))
+    measure_valued_log_scale_grads = np.mean(
+        measure_valued_log_scale_jacobians, axis=0)
+
+    pathwise_jacobians = _estimator_variant(
+        self.variant, sge.pathwise_jacobians)(function, [mean, log_scale],
+                                              utils.multi_normal, pathwise_rng,
+                                              num_samples)
+
+    pathwise_mean_jacobians = pathwise_jacobians[0]
+    chex.assert_shape(pathwise_mean_jacobians, (num_samples, data_dims))
+    pathwise_mean_grads = np.mean(pathwise_mean_jacobians, axis=0)
+
+    pathwise_log_scale_jacobians = pathwise_jacobians[1]
+    chex.assert_shape(pathwise_log_scale_jacobians, (num_samples, data_dims))
+    pathwise_log_scale_grads = np.mean(pathwise_log_scale_jacobians, axis=0)
+
+    _assert_equal(
+        pathwise_mean_grads, measure_valued_mean_grads, rtol=5e-1, atol=1e-1)
+    _assert_equal(
+        pathwise_log_scale_grads, measure_valued_log_scale_grads,
+        rtol=5e-1, atol=1e-1)
+
+
+class MeasuredValuedEstimatorsTest(chex.TestCase):
+
+  @chex.all_variants
+  @parameterized.parameters([True, False])
+  def testRaisesErrorForNonGaussian(self, coupling):
+    num_samples = 10**5
+    rng = jax.random.PRNGKey(1)
+
+    function = lambda x: jnp.sum(x) ** 2
+
+    mean = jnp.array(0, dtype=jnp.float32)
+    log_scale = jnp.array(0., dtype=jnp.float32)
+
+    class TestDist():
+
+      def __init__(self, params):
+        self._params = params
+
+      def sample(self, n):
+        return np.zeros(n)
+
+    with self.assertRaises(ValueError):
+      _measure_valued_variant(self.variant)(
+          function, [mean, log_scale],
+          TestDist, rng, num_samples, coupling)
+
+
+if __name__ == '__main__':
+  absltest.main()

testbed/google-deepmind__optax/optax/optax_test.py

@@ -0,0 +1,32 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for optax."""
+
+from absl.testing import absltest
+
+import optax
+from optax import transforms
+
+
+class OptaxTest(absltest.TestCase):
+  """Test optax can be imported correctly."""
+
+  def test_import(self):
+    self.assertTrue(hasattr(optax, 'GradientTransformation'))
+    self.assertTrue(hasattr(transforms, 'partition'))
+
+
+if __name__ == '__main__':
+  absltest.main()

testbed/google-deepmind__optax/optax/projections/__init__.py

@@ -0,0 +1,21 @@
+# Copyright 2021 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""The projections sub-package."""
+
+from optax.projections._projections import projection_box
+from optax.projections._projections import projection_hypercube
+from optax.projections._projections import projection_non_negative
+from optax.projections._projections import projection_simplex

testbed/google-deepmind__optax/optax/projections/_projections.py

@@ -0,0 +1,163 @@
+# Copyright 2021 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Euclidean projections."""
+
+from typing import Any
+
+import chex
+
+import jax
+from jax import flatten_util
+from jax import tree_util as jtu
+import jax.numpy as jnp
+
+
+def projection_non_negative(pytree: Any) -> Any:
+  r"""Projection onto the non-negative orthant.
+
+  .. math::
+
+    \underset{p}{\text{argmin}} ~ ||x - p||_2^2 \quad
+    \textrm{subject to} \quad p \ge 0
+
+  where :math:`x` is the input pytree.
+
+  Args:
+    pytree: pytree to project.
+  Returns:
+    projected pytree, with the same structure as ``pytree``.
+  """
+  return jtu.tree_map(jax.nn.relu, pytree)
+
+
+def _clip_safe(leaf, lower, upper):
+  return jnp.clip(jnp.asarray(leaf), lower, upper)
+
+
+def projection_box(pytree: Any, lower: Any, upper: Any) -> Any:
+  r"""Projection onto box constraints.
+
+  .. math::
+
+    \underset{p}{\text{argmin}} ~ ||x - p||_2^2 \quad \textrm{subject to} \quad
+    \text{lower} \le p \le \text{upper}
+
+  where :math:`x` is the input pytree.
+
+  Args:
+    pytree: pytree to project.
+    lower:  lower bound, a scalar or pytree with the same structure as
+      ``pytree``.
+    upper:  upper bound, a scalar or pytree with the same structure as
+      ``pytree``.
+  Returns:
+    projected pytree, with the same structure as ``pytree``.
+  """
+  return jtu.tree_map(_clip_safe, pytree, lower, upper)
+
+
+def projection_hypercube(pytree: Any, scale: Any = 1.0) -> Any:
+  r"""Projection onto the (unit) hypercube.
+
+  .. math::
+
+    \underset{p}{\text{argmin}} ~ ||x - p||_2^2 \quad \textrm{subject to} \quad
+    0 \le p \le \text{scale}
+
+  where :math:`x` is the input pytree.
+
+  By default, we project to the unit hypercube (`scale=1.0`).
+
+  This is a convenience wrapper around
+  :func:`projection_box <optax.projections.projection_box>`.
+
+  Args:
+    pytree: pytree to project.
+    scale: scale of the hypercube, a scalar or a pytree (default: 1.0).
+  Returns:
+    projected pytree, with the same structure as ``pytree``.
+  """
+  return projection_box(pytree, lower=0.0, upper=scale)
+
+
+@jax.custom_jvp
+def _projection_unit_simplex(values: chex.Array) -> chex.Array:
+  """Projection onto the unit simplex."""
+  s = 1.0
+  n_features = values.shape[0]
+  u = jnp.sort(values)[::-1]
+  cumsum_u = jnp.cumsum(u)
+  ind = jnp.arange(n_features) + 1
+  cond = s / ind + (u - cumsum_u / ind) > 0
+  idx = jnp.count_nonzero(cond)
+  return jax.nn.relu(s / idx + (values - cumsum_u[idx - 1] / idx))
+
+
+@_projection_unit_simplex.defjvp
+def _projection_unit_simplex_jvp(
+    primals: list[chex.Array], tangents: list[chex.Array]
+) -> tuple[chex.Array, chex.Array]:
+  values, = primals
+  values_dot, = tangents
+  primal_out = _projection_unit_simplex(values)
+  supp = primal_out > 0
+  card = jnp.count_nonzero(supp)
+  tangent_out = supp * values_dot - (jnp.dot(supp, values_dot) / card) * supp
+  return primal_out, tangent_out
+
+
+def projection_simplex(pytree: Any,
+                       scale: chex.Numeric = 1.0) -> Any:
+  r"""Projection onto a simplex.
+
+  This function solves the following constrained optimization problem,
+  where ``p`` is the input pytree.
+
+  .. math::
+
+    \underset{p}{\text{argmin}} ~ ||x - p||_2^2 \quad \textrm{subject to} \quad
+    p \ge 0, p^\top 1 = \text{scale}
+
+  By default, the projection is onto the probability simplex (unit simplex).
+
+  Args:
+    pytree: pytree to project.
+    scale: value the projected pytree should sum to (default: 1.0).
+  Returns:
+    projected pytree, a pytree with the same structure as ``pytree``.
+
+  .. versionadded:: 0.2.3
+
+  Example:
+
+    Here is an example using a pytree::
+
+      >>> import jax.numpy as jnp
+      >>> from optax import tree_utils, projections
+      >>> pytree = {"w": jnp.array([2.5, 3.2]), "b": 0.5}
+      >>> tree_utils.tree_sum(pytree)
+      6.2
+      >>> new_pytree = projections.projection_simplex(pytree)
+      >>> tree_utils.tree_sum(new_pytree)
+      1.0000002
+  """
+  if scale is None:
+    scale = 1.0
+
+  values, unravel_fn = flatten_util.ravel_pytree(pytree)
+  new_values = scale * _projection_unit_simplex(values / scale)
+
+  return unravel_fn(new_values)

testbed/google-deepmind__optax/optax/projections/_projections_test.py

@@ -0,0 +1,172 @@
+# Copyright 2021 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tests for optax.projections."""
+
+from absl.testing import absltest
+from absl.testing import parameterized
+import chex
+import jax
+import jax.numpy as jnp
+import numpy as np
+from optax import projections as proj
+import optax.tree_utils as otu
+
+
+def projection_simplex_jacobian(projection):
+  """Theoretical expression for the Jacobian of projection_simplex."""
+  support = (projection > 0).astype(jnp.int32)
+  cardinality = jnp.count_nonzero(support)
+  return jnp.diag(support) - jnp.outer(support, support) / cardinality
+
+
+class ProjectionsTest(parameterized.TestCase):
+
+  def test_projection_non_negative(self):
+    with self.subTest('with an array'):
+      x = jnp.array([-1.0, 2.0, 3.0])
+      expected = jnp.array([0, 2.0, 3.0])
+      np.testing.assert_array_equal(proj.projection_non_negative(x), expected)
+
+    with self.subTest('with a tuple'):
+      np.testing.assert_array_equal(
+          proj.projection_non_negative((x, x)), (expected, expected)
+      )
+
+    with self.subTest('with nested pytree'):
+      tree_x = (-1.0, {'k1': 1.0, 'k2': (1.0, 1.0)}, 1.0)
+      tree_expected = (0.0, {'k1': 1.0, 'k2': (1.0, 1.0)}, 1.0)
+      chex.assert_trees_all_equal(
+          proj.projection_non_negative(tree_x), tree_expected
+      )
+
+  def test_projection_box(self):
+    with self.subTest('lower and upper are scalars'):
+      lower, upper = 0.0, 2.0
+      x = jnp.array([-1.0, 2.0, 3.0])
+      expected = jnp.array([0, 2.0, 2.0])
+      np.testing.assert_array_equal(
+          proj.projection_box(x, lower, upper), expected
+      )
+
+    with self.subTest('lower and upper values are arrays'):
+      lower_arr = jnp.ones(len(x)) * lower
+      upper_arr = jnp.ones(len(x)) * upper
+      np.testing.assert_array_equal(
+          proj.projection_box(x, lower_arr, upper_arr), expected
+      )
+
+    with self.subTest('lower and upper are tuples of arrays'):
+      lower_tuple = (lower, lower)
+      upper_tuple = (upper, upper)
+      chex.assert_trees_all_equal(
+          proj.projection_box((x, x), lower_tuple, upper_tuple),
+          (expected, expected),
+      )
+
+    with self.subTest('lower and upper are pytrees'):
+      tree = (-1.0, {'k1': 2.0, 'k2': (2.0, 3.0)}, 3.0)
+      expected = (0.0, {'k1': 2.0, 'k2': (2.0, 2.0)}, 2.0)
+      lower_tree = (0.0, {'k1': 0.0, 'k2': (0.0, 0.0)}, 0.0)
+      upper_tree = (2.0, {'k1': 2.0, 'k2': (2.0, 2.0)}, 2.0)
+      chex.assert_trees_all_equal(
+          proj.projection_box(tree, lower_tree, upper_tree), expected
+      )
+
+  def test_projection_hypercube(self):
+    x = jnp.array([-1.0, 2.0, 0.5])
+
+    with self.subTest('with default scale'):
+      expected = jnp.array([0, 1.0, 0.5])
+      np.testing.assert_array_equal(proj.projection_hypercube(x), expected)
+
+    with self.subTest('with scalar scale'):
+      expected = jnp.array([0, 0.8, 0.5])
+      np.testing.assert_array_equal(proj.projection_hypercube(x, 0.8), expected)
+
+    with self.subTest('with array scales'):
+      scales = jnp.ones(len(x)) * 0.8
+      np.testing.assert_array_equal(
+          proj.projection_hypercube(x, scales), expected
+      )
+
+  @parameterized.parameters(1.0, 0.8)
+  def test_projection_simplex_array(self, scale):
+    rng = np.random.RandomState(0)
+    x = rng.randn(50).astype(np.float32)
+    p = proj.projection_simplex(x, scale)
+
+    np.testing.assert_almost_equal(jnp.sum(p), scale, decimal=4)
+    self.assertTrue(jnp.all(0 <= p))
+    self.assertTrue(jnp.all(p <= scale))
+
+  @parameterized.parameters(1.0, 0.8)
+  def test_projection_simplex_pytree(self, scale):
+    pytree = {'w': jnp.array([2.5, 3.2]), 'b': 0.5}
+    new_pytree = proj.projection_simplex(pytree, scale)
+    np.testing.assert_almost_equal(otu.tree_sum(new_pytree), scale, decimal=4)
+
+  @parameterized.parameters(1.0, 0.8)
+  def test_projection_simplex_edge_case(self, scale):
+    p = proj.projection_simplex(jnp.array([0.0, 0.0, -jnp.inf]), scale)
+    np.testing.assert_array_almost_equal(
+        p, jnp.array([scale / 2, scale / 2, 0.0])
+    )
+
+  def test_projection_simplex_jacobian(self):
+    rng = np.random.RandomState(0)
+
+    x = rng.rand(5).astype(np.float32)
+    v = rng.randn(5).astype(np.float32)
+
+    jac_rev = jax.jacrev(proj.projection_simplex)(x)
+    jac_fwd = jax.jacfwd(proj.projection_simplex)(x)
+
+    with self.subTest('Check against theoretical expression'):
+      p = proj.projection_simplex(x)
+      jac_true = projection_simplex_jacobian(p)
+
+      np.testing.assert_array_almost_equal(jac_true, jac_fwd)
+      np.testing.assert_array_almost_equal(jac_true, jac_rev)
+
+    with self.subTest('Check against finite difference'):
+      jvp = jax.jvp(proj.projection_simplex, (x,), (v,))[1]
+      eps = 1e-4
+      jvp_finite_diff = (proj.projection_simplex(x + eps * v) -
+                         proj.projection_simplex(x - eps * v)) / (2 * eps)
+      np.testing.assert_array_almost_equal(jvp, jvp_finite_diff, decimal=3)
+
+    with self.subTest('Check vector-Jacobian product'):
+      (vjp,) = jax.vjp(proj.projection_simplex, x)[1](v)
+      np.testing.assert_array_almost_equal(vjp, jnp.dot(v, jac_true))
+
+    with self.subTest('Check Jacobian-vector product'):
+      jvp = jax.jvp(proj.projection_simplex, (x,), (v,))[1]
+      np.testing.assert_array_almost_equal(jvp, jnp.dot(jac_true, v))
+
+  @parameterized.parameters(1.0, 0.8)
+  def test_projection_simplex_vmap(self, scale):
+    rng = np.random.RandomState(0)
+    x = rng.randn(3, 50).astype(np.float32)
+    scales = jnp.full(len(x), scale)
+
+    p = jax.vmap(proj.projection_simplex)(x, scales)
+    np.testing.assert_array_almost_equal(jnp.sum(p, axis=1), scales)
+    np.testing.assert_array_equal(True, 0 <= p)
+    np.testing.assert_array_equal(True, p <= scale)
+
+
+if __name__ == '__main__':
+  absltest.main()

testbed/google-deepmind__optax/optax/schedules/_inject_test.py

@@ -0,0 +1,249 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for `inject.py`."""
+
+import functools
+from typing import NamedTuple
+
+from absl.testing import absltest
+from absl.testing import parameterized
+import chex
+import jax
+import jax.numpy as jnp
+import numpy as np
+from optax._src import base
+from optax._src import clipping
+from optax._src import transform
+from optax._src import wrappers
+from optax.schedules import _inject
+from optax.schedules import _schedule
+from optax.tree_utils import _state_utils
+
+
+class ExampleState(NamedTuple):
+  total: chex.Numeric
+
+
+class ExampleStatefulSchedule(base.StatefulSchedule):
+
+  def init(self) -> ExampleState:
+    return ExampleState(total=jnp.zeros([], dtype=jnp.int32))
+
+  def update(self, state: ExampleState, **extra_args) -> ExampleState:
+    total = state.total + extra_args['addendum']
+    return ExampleState(total=total)
+
+  def __call__(self, state: ExampleState, **extra_args) -> chex.Numeric:
+    return state.total
+
+
+class InjectHyperparamsTest(chex.TestCase):
+  """Tests for the inject_hyperparams wrapper."""
+
+  @chex.all_variants
+  def test_updates(self):
+    optim = _inject.inject_hyperparams(transform.scale)(  # stateless
+        step_size=_schedule.piecewise_constant_schedule(
+            3.0, {1: 5, 7: 2, 12: 1.5}))
+
+    params = [jnp.zeros([], dtype=jnp.float32)]
+    state = self.variant(optim.init)(params)
+
+    # A no-op change, to verify that tree map works.
+    state = _state_utils.tree_map_params(optim, lambda v: v, state)
+
+    update_fn = self.variant(optim.update)
+    expected_step_size = [3.0]*2 + [15.0]*6 + [30.0]*5 + [45.0]*3
+
+    grads = [jnp.ones([], dtype=jnp.float32)]
+    for i in range(15):
+      updates, state = update_fn(grads, state, params=params)
+      np.testing.assert_almost_equal(updates[0], expected_step_size[i+1])
+
+  @chex.all_variants
+  def test_hyperparams_state(self):
+    optim = _inject.inject_hyperparams(transform.trace)(  # stateful
+        decay=_schedule.piecewise_constant_schedule(
+            0.8, {3: 0.5, 9: 1.25}),
+        nesterov=True)
+
+    params = [jnp.zeros([2, 3]) for _ in range(3)]
+    state = self.variant(optim.init)(params)
+    update_fn = self.variant(optim.update)
+
+    expected_mom = [0.8]*4 + [0.4]*6 + [0.5]*2
+    grads = jax.tree_util.tree_map(jnp.ones_like, params)
+    for i in range(12):
+      np.testing.assert_almost_equal(state.hyperparams['decay'],
+                                     expected_mom[i])
+      _, state = update_fn(grads, state)
+
+    np.testing.assert_almost_equal(state.hyperparams['decay'],
+                                   expected_mom[-1])
+
+  @chex.all_variants
+  def test_constant_hyperparams(self):
+    optim = _inject.inject_hyperparams(transform.scale_by_adam)(b1=0., b2=0.)
+
+    params = [jnp.zeros([2, 3]) for _ in range(3)]
+    state = self.variant(optim.init)(params)
+    update_fn = self.variant(optim.update)
+
+    grads = jax.tree_util.tree_map(jnp.ones_like, params)
+    for _ in range(5):
+      updates, state = update_fn(grads, state, params)
+      np.testing.assert_almost_equal(state.hyperparams['b1'], 0.0)
+      np.testing.assert_almost_equal(state.hyperparams['b2'], 0.0)
+      np.testing.assert_almost_equal(state.hyperparams['eps'], 1e-8)
+      np.testing.assert_almost_equal(state.hyperparams['eps_root'], 0.0)
+      assert 'eps' in state.hyperparams
+      chex.assert_trees_all_close(updates, grads)
+
+  @chex.all_variants
+  def test_overriding_hyperparam(self):
+    optim = _inject.inject_hyperparams(clipping.clip_by_global_norm)(0.1)
+    params = jnp.zeros((3, 5, 7))
+    state = self.variant(optim.init)(params)
+    update_fn = self.variant(optim.update)
+
+    grads = jnp.ones_like(params)
+    for i in range(5):
+      state.hyperparams['max_norm'] = i
+      updates, state = update_fn(grads, state)
+      assert np.isclose(jnp.linalg.norm(updates.ravel()), i)
+
+  @chex.all_variants
+  @parameterized.named_parameters(('string', 'mask'), ('list', ['mask']))
+  def test_static_args(self, static_args):
+    @functools.partial(_inject.inject_hyperparams, static_args=static_args)
+    def custom_optim(learning_rate, mask):
+      return wrappers.masked(transform.scale(-learning_rate), mask)
+
+    optim = custom_optim(
+        0.1, functools.partial(jax.tree_util.tree_map, lambda x: x.ndim > 1))
+    params = [jnp.ones((1, 2)), jnp.ones(2), jnp.ones((1, 1, 1))]
+    grads = params
+    state = self.variant(optim.init)(params)
+    updates, state = self.variant(optim.update)(grads, state)
+    expected_updates = jax.tree_util.tree_map(
+        lambda x: -0.1 * x if x.ndim > 1 else x, grads)
+
+    assert set(state.hyperparams.keys()) == {'learning_rate'}, state.hyperparams
+    chex.assert_trees_all_close(updates, expected_updates)
+
+  @chex.all_variants
+  @parameterized.named_parameters(('one_arg', 'b1'), ('two_arg', ['b1', 'b2']))
+  def test_numeric_static_args(self, static_args):
+    optim = _inject.inject_hyperparams(
+        transform.scale_by_adam, static_args=static_args)(b1=0.9, b2=0.95)
+
+    params = [jnp.ones((1, 2)), jnp.ones(2), jnp.ones((1, 1, 1))]
+    grads = params
+    state = self.variant(optim.init)(params)
+    _, state = self.variant(optim.update)(grads, state)
+
+    assert not set(state.hyperparams.keys()).intersection(set(static_args))
+
+  @chex.all_variants
+  @parameterized.named_parameters(
+      ('bf16hyp f32param bf16grad', jnp.bfloat16, jnp.float32, jnp.bfloat16),
+      ('bf16hyp f32param f32_grads', jnp.bfloat16, jnp.float32, jnp.float32),
+      ('f32hyp bf16param bf16grad', jnp.float32, jnp.bfloat16, jnp.bfloat16),
+      ('f32hyp f32param bf16grad', jnp.float32, jnp.float32, jnp.bfloat16),
+      ('f32hyp bf16param f32grad', jnp.float32, jnp.bfloat16, jnp.float32),
+      )
+  def test_hyperparam_dtypes(self,
+                             hyperparam_dtype,
+                             param_dtype,
+                             grad_dtype):
+    """Tests that hyperparam dtype override works as desired."""
+    optim = _inject.inject_hyperparams(
+        transform.scale_by_adam,
+        hyperparam_dtype=hyperparam_dtype)(b1=0.9, b2=0.95)
+
+    params = [jnp.ones((1, 2), dtype=param_dtype),
+              jnp.ones(2, dtype=param_dtype),
+              jnp.ones((1, 1, 1), dtype=param_dtype)]
+    grads = jax.tree_util.tree_map(lambda x: x.astype(grad_dtype), params)
+    state = self.variant(optim.init)(params)
+    # Check that the hyperparams are overridden
+    self.assertEqual(state.hyperparams['b1'].dtype, hyperparam_dtype)
+    self.assertEqual(state.hyperparams['b2'].dtype, hyperparam_dtype)
+
+    _, state = self.variant(optim.update)(grads, state)
+
+    self.assertEqual(state.hyperparams['b1'].dtype, hyperparam_dtype)
+    self.assertEqual(state.hyperparams['b2'].dtype, hyperparam_dtype)
+
+  @parameterized.named_parameters(('string', 'lr'), ('list', ['lr']))
+  def test_static_args_error(self, static_args):
+    with self.assertRaises(ValueError):
+      _inject.inject_hyperparams(transform.scale, static_args=static_args)
+
+  @chex.all_variants
+  def test_inject_hyperparams_starts_with_step_count_zero(self):
+    """Checks that inject_hyperparams uses step count 0 in the first update."""
+    # See also: https://github.com/deepmind/optax/issues/415.
+    opt = _inject.inject_hyperparams(transform.scale)(lambda count: count)
+    params = jnp.zeros(3)
+    grads = jnp.array([-1, 0, 1])
+    updates, _ = self.variant(opt.update)(grads, opt.init(params))
+    np.testing.assert_array_equal(updates, np.zeros(3))
+
+
+class StatefulTest(chex.TestCase):
+
+  def test_wrap_stateless_schedule(self):
+    my_schedule = _schedule.linear_schedule(1., 1., 10)
+    my_wrapped_schedule = _inject.WrappedSchedule(my_schedule)
+
+    count = jnp.zeros([], dtype=jnp.int32)
+    state = my_wrapped_schedule.init()
+    np.testing.assert_allclose(count, state, atol=0.0)
+
+    for _ in range(8):
+      np.testing.assert_allclose(
+          my_schedule(count), my_wrapped_schedule(state), atol=0.0)
+      count = count + 1
+      extra_args = dict(loss=jnp.ones([], dtype=jnp.float32))
+      state = my_wrapped_schedule.update(state, **extra_args)
+      np.testing.assert_allclose(count, state, atol=0.0)
+
+  @chex.all_variants
+  def test_inject_stateful_hyperparams(self):
+    grads = (
+        jnp.ones((3,), dtype=jnp.float32),
+        jnp.ones((2,), dtype=jnp.float32),)
+    params = grads
+
+    my_stateful_schedule = ExampleStatefulSchedule()
+    tx = _inject.inject_hyperparams(
+        transform.scale)(step_size=my_stateful_schedule)
+    state = self.variant(tx.init)(params)
+
+    extra_args = dict(addendum=0.3 * jnp.ones((), dtype=jnp.float32))
+    _, state = self.variant(tx.update)(
+        grads, state, params=params, **extra_args)
+    _, state = self.variant(tx.update)(
+        grads, state, params=params, **extra_args)
+
+    lr = state.hyperparams['step_size']
+    total = state.hyperparams_states['step_size']
+
+    np.testing.assert_allclose(lr, extra_args['addendum'], atol=0.0)
+    np.testing.assert_allclose(total, 2 * extra_args['addendum'], atol=0.0)
+
+if __name__ == '__main__':
+  absltest.main()

testbed/google-deepmind__optax/optax/schedules/_join.py

@@ -0,0 +1,45 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Utilities to join schedules."""
+
+from typing import Sequence
+
+import chex
+import jax.numpy as jnp
+
+from optax._src import base
+
+
+def join_schedules(
+    schedules: Sequence[base.Schedule],
+    boundaries: Sequence[int]
+) -> base.Schedule:
+  """Sequentially apply multiple schedules.
+
+  Args:
+    schedules: A list of callables (expected to be optax schedules). Each
+      schedule will receive a step count indicating the number of steps since
+      the previous boundary transition.
+    boundaries: A list of integers (of length one less than schedules) that
+      indicate when to transition between schedules.
+  Returns:
+    schedule: A function that maps step counts to values.
+  """
+  def schedule(step: chex.Numeric) -> chex.Numeric:
+    output = schedules[0](step)
+    for boundary, schedule in zip(boundaries, schedules[1:]):
+      output = jnp.where(step < boundary, output, schedule(step - boundary))
+    return output
+  return schedule

testbed/google-deepmind__optax/optax/schedules/_join_test.py

@@ -0,0 +1,44 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for `join.py`."""
+
+from absl.testing import absltest
+
+import numpy as np
+
+from optax.schedules import _join
+from optax.schedules import _schedule
+
+
+class JoinTest(absltest.TestCase):
+
+  def test_join_schedules(self):
+    my_schedule = _join.join_schedules(
+        schedules=[
+            _schedule.constant_schedule(1.),
+            _schedule.constant_schedule(2.),
+            _schedule.constant_schedule(1.)],
+        boundaries=[3, 6])
+    np.testing.assert_allclose(1., my_schedule(0), atol=0.0)
+    np.testing.assert_allclose(1., my_schedule(1), atol=0.0)
+    np.testing.assert_allclose(1., my_schedule(2), atol=0.0)
+    np.testing.assert_allclose(2., my_schedule(3), atol=0.0)
+    np.testing.assert_allclose(2., my_schedule(4), atol=0.0)
+    np.testing.assert_allclose(2., my_schedule(5), atol=0.0)
+    np.testing.assert_allclose(1., my_schedule(6), atol=0.0)
+
+
+if __name__ == "__main__":
+  absltest.main()

testbed/google-deepmind__optax/optax/second_order/__init__.py

@@ -0,0 +1,19 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""The second order optimisation sub-package."""
+
+from optax.second_order._fisher import fisher_diag
+from optax.second_order._hessian import hessian_diag
+from optax.second_order._hessian import hvp

testbed/google-deepmind__optax/optax/second_order/_base.py

@@ -0,0 +1,30 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Base types for the second order sub-package."""
+
+import abc
+from typing import Any, Protocol
+
+import jax
+
+
+class LossFn(Protocol):
+  """A loss function to be optimized."""
+
+  @abc.abstractmethod
+  def __call__(
+      self, params: Any, inputs: jax.Array, targets: jax.Array
+  ) -> jax.Array:
+    ...

testbed/google-deepmind__optax/optax/second_order/_hessian.py

@@ -0,0 +1,80 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Functions for computing diagonals of the Hessian wrt to a set of parameters.
+
+Computing the Hessian for neural networks is typically intractible due to the
+quadratic memory requirements. Solving for the diagonal can be done cheaply,
+with sub-quadratic memory requirements.
+"""
+
+from typing import Any
+
+import jax
+from jax import flatten_util
+import jax.numpy as jnp
+
+from optax.second_order import _base
+
+
+def _ravel(p: Any) -> jax.Array:
+  return flatten_util.ravel_pytree(p)[0]
+
+
+def hvp(
+    loss: _base.LossFn,
+    v: jax.Array,
+    params: Any,
+    inputs: jax.Array,
+    targets: jax.Array,
+) -> jax.Array:
+  """Performs an efficient vector-Hessian (of `loss`) product.
+
+  Args:
+    loss: the loss function.
+    v: a vector of size `ravel(params)`.
+    params: model parameters.
+    inputs: inputs at which `loss` is evaluated.
+    targets: targets at which `loss` is evaluated.
+
+  Returns:
+    An Array corresponding to the product of `v` and the Hessian of `loss`
+    evaluated at `(params, inputs, targets)`.
+  """
+  _, unravel_fn = flatten_util.ravel_pytree(params)
+  loss_fn = lambda p: loss(p, inputs, targets)
+  return jax.jvp(jax.grad(loss_fn), [params], [unravel_fn(v)])[1]
+
+
+def hessian_diag(
+    loss: _base.LossFn,
+    params: Any,
+    inputs: jax.Array,
+    targets: jax.Array,
+) -> jax.Array:
+  """Computes the diagonal hessian of `loss` at (`inputs`, `targets`).
+
+  Args:
+    loss: the loss function.
+    params: model parameters.
+    inputs: inputs at which `loss` is evaluated.
+    targets: targets at which `loss` is evaluated.
+
+  Returns:
+    A DeviceArray corresponding to the product to the Hessian of `loss`
+    evaluated at `(params, inputs, targets)`.
+  """
+  vs = jnp.eye(_ravel(params).size)
+  comp = lambda v: jnp.vdot(v, _ravel(hvp(loss, v, params, inputs, targets)))
+  return jax.vmap(comp)(vs)

testbed/google-deepmind__optax/optax/second_order/_hessian_test.py

@@ -0,0 +1,88 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for `hessian.py`."""
+
+import functools
+
+from absl.testing import absltest
+
+import chex
+from flax import linen as nn
+import jax
+import jax.numpy as jnp
+import numpy as np
+
+from optax.second_order import _hessian
+
+
+NUM_CLASSES = 2
+NUM_SAMPLES = 3
+NUM_FEATURES = 4
+
+
+class HessianTest(chex.TestCase):
+
+  def setUp(self):
+    super().setUp()
+
+    self.data = np.random.rand(NUM_SAMPLES, NUM_FEATURES)
+    self.labels = np.random.randint(NUM_CLASSES, size=NUM_SAMPLES)
+
+    class MLP(nn.Module):
+      """A simple multilayer perceptron model for image classification."""
+
+      @nn.compact
+      def __call__(self, x):
+        # Flattens images in the batch.
+        x = x.reshape((x.shape[0], -1))
+        x = nn.Dense(features=5)(x)
+        x = nn.relu(x)
+        x = nn.Dense(features=NUM_CLASSES)(x)
+        return x
+
+    net = MLP()
+    self.parameters = net.init({'params': jax.random.PRNGKey(0)}, self.data)[
+        'params'
+    ]
+
+    def loss(params, inputs, targets):
+      log_probs = net.apply({'params': params}, inputs)
+      return -jnp.mean(jax.nn.one_hot(targets, NUM_CLASSES) * log_probs)
+
+    self.loss_fn = loss
+
+    def jax_hessian_diag(loss_fun, params, inputs, targets):
+      """This is the 'ground-truth' obtained via the JAX library."""
+      flat_params, unravel_fn = jax.flatten_util.ravel_pytree(params)
+
+      def flattened_loss(flat_params):
+        return loss_fun(unravel_fn(flat_params), inputs, targets)
+
+      flat_hessian = jax.hessian(flattened_loss)(flat_params)
+      return jnp.diag(flat_hessian)
+
+    self.hessian_diag = jax_hessian_diag(
+        self.loss_fn, self.parameters, self.data, self.labels)
+
+  @chex.all_variants
+  def test_hessian_diag(self):
+    hessian_diag_fn = self.variant(
+        functools.partial(_hessian.hessian_diag, self.loss_fn))
+    actual = hessian_diag_fn(self.parameters, self.data, self.labels)
+    np.testing.assert_array_almost_equal(self.hessian_diag, actual, 5)
+
+
+if __name__ == '__main__':
+  absltest.main()

testbed/google-deepmind__optax/optax/transforms/__init__.py

@@ -0,0 +1,92 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""The transforms sub-package."""
+
+from optax.transforms._accumulation import ema
+from optax.transforms._accumulation import EmaState
+from optax.transforms._accumulation import MultiSteps
+from optax.transforms._accumulation import MultiStepsState
+from optax.transforms._accumulation import ShouldSkipUpdateFunction
+from optax.transforms._accumulation import skip_large_updates
+from optax.transforms._accumulation import skip_not_finite
+from optax.transforms._accumulation import trace
+from optax.transforms._accumulation import TraceState
+from optax.transforms._adding import add_decayed_weights
+from optax.transforms._adding import add_noise
+from optax.transforms._adding import AddNoiseState
+from optax.transforms._clipping import adaptive_grad_clip
+from optax.transforms._clipping import clip
+from optax.transforms._clipping import clip_by_block_rms
+from optax.transforms._clipping import clip_by_global_norm
+from optax.transforms._clipping import per_example_global_norm_clip
+from optax.transforms._clipping import per_example_layer_norm_clip
+from optax.transforms._clipping import unitwise_clip
+from optax.transforms._clipping import unitwise_norm
+from optax.transforms._combining import chain
+from optax.transforms._combining import named_chain
+from optax.transforms._combining import partition
+from optax.transforms._combining import PartitionState
+from optax.transforms._conditionality import apply_if_finite
+from optax.transforms._conditionality import ApplyIfFiniteState
+from optax.transforms._conditionality import conditionally_mask
+from optax.transforms._conditionality import conditionally_transform
+from optax.transforms._conditionality import ConditionallyMaskState
+from optax.transforms._conditionality import ConditionallyTransformState
+from optax.transforms._conditionality import ConditionFn
+from optax.transforms._constraining import keep_params_nonnegative
+from optax.transforms._constraining import NonNegativeParamsState
+from optax.transforms._constraining import zero_nans
+from optax.transforms._constraining import ZeroNansState
+from optax.transforms._layouts import flatten
+from optax.transforms._masking import masked
+from optax.transforms._masking import MaskedNode
+from optax.transforms._masking import MaskedState
+
+
+__all__ = (
+    "adaptive_grad_clip",
+    "add_decayed_weights",
+    "add_noise",
+    "AddNoiseState",
+    "apply_if_finite",
+    "ApplyIfFiniteState",
+    "chain",
+    "clip_by_block_rms",
+    "clip_by_global_norm",
+    "clip",
+    "conditionally_mask",
+    "ConditionallyMaskState",
+    "conditionally_transform",
+    "ConditionallyTransformState",
+    "ema",
+    "EmaState",
+    "flatten",
+    "keep_params_nonnegative",
+    "masked",
+    "MaskedState",
+    "MultiSteps",
+    "MultiStepsState",
+    "named_chain",
+    "NonNegativeParamsState",
+    "partition",
+    "PartitionState",
+    "ShouldSkipUpdateFunction",
+    "skip_large_updates",
+    "skip_not_finite",
+    "trace",
+    "TraceState",
+    "zero_nans",
+    "ZeroNansState",
+)

testbed/google-deepmind__optax/optax/transforms/_accumulation.py

@@ -0,0 +1,393 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Gradient transformations for accumulating gradients across updates."""
+
+from typing import Any, Callable, NamedTuple, Optional, Protocol, Union
+
+import chex
+from jax import lax
+from jax import tree_util as jtu
+import jax.numpy as jnp
+
+from optax import tree_utils as otu
+
+from optax._src import base
+from optax._src import numerics
+from optax._src import utils
+
+
+class TraceState(NamedTuple):
+  """Holds an aggregation of past updates."""
+  trace: base.Params
+
+
+def trace(
+    decay: float,
+    nesterov: bool = False,
+    accumulator_dtype: Optional[Any] = None,
+) -> base.GradientTransformation:
+  """Compute a trace of past updates.
+
+  Note: `trace` and `ema` have very similar but distinct updates;
+  `trace = decay * trace + t`, while `ema = decay * ema + (1-decay) * t`.
+  Both are frequently found in the optimization literature.
+
+  Args:
+    decay: Decay rate for the trace of past updates.
+    nesterov: Whether to use Nesterov momentum.
+    accumulator_dtype: Optional `dtype` to be used for the accumulator; if
+      `None` then the `dtype` is inferred from `params` and `updates`.
+
+  Returns:
+    A `GradientTransformation` object.
+  """
+
+  accumulator_dtype = utils.canonicalize_dtype(accumulator_dtype)
+
+  def init_fn(params):
+    return TraceState(
+        trace=otu.tree_zeros_like(params, dtype=accumulator_dtype))
+
+  def update_fn(updates, state, params=None):
+    del params
+    f = lambda g, t: g + decay * t
+    new_trace = jtu.tree_map(f, updates, state.trace)
+    updates = jtu.tree_map(f, updates, new_trace) if nesterov else new_trace
+    new_trace = otu.tree_cast(new_trace, accumulator_dtype)
+    return updates, TraceState(trace=new_trace)
+
+  return base.GradientTransformation(init_fn, update_fn)
+
+
+class EmaState(NamedTuple):
+  """Holds an exponential moving average of past updates."""
+  count: chex.Array  # shape=(), dtype=jnp.int32.
+  ema: base.Params
+
+
+def ema(
+    decay: float,
+    debias: bool = True,
+    accumulator_dtype: Optional[Any] = None
+) -> base.GradientTransformation:
+  """Compute an exponential moving average of past updates.
+
+  Note: `trace` and `ema` have very similar but distinct updates;
+  `ema = decay * ema + (1-decay) * t`, while `trace = decay * trace + t`.
+  Both are frequently found in the optimization literature.
+
+  Args:
+    decay: Decay rate for the exponential moving average.
+    debias: Whether to debias the transformed gradient.
+    accumulator_dtype: Optional `dtype` to used for the accumulator; if `None`
+      then the `dtype` is inferred from `params` and `updates`.
+
+  Returns:
+    A `GradientTransformation` object.
+  """
+
+  accumulator_dtype = utils.canonicalize_dtype(accumulator_dtype)
+
+  def init_fn(params):
+    return EmaState(
+        count=jnp.zeros([], jnp.int32),
+        ema=otu.tree_zeros_like(params, dtype=accumulator_dtype))
+
+  def update_fn(updates, state, params=None):
+    del params
+    updates = new_ema = otu.tree_update_moment(
+        updates, state.ema, decay, order=1)
+    count_inc = utils.safe_int32_increment(state.count)
+    if debias:
+      updates = otu.tree_bias_correction(new_ema, decay, count_inc)
+    state_ema = otu.tree_cast(new_ema, accumulator_dtype)
+    return updates, EmaState(count=count_inc, ema=state_ema)
+
+  return base.GradientTransformation(init_fn, update_fn)
+
+
+class ShouldSkipUpdateFunction(Protocol):
+
+  def __call__(
+      self,
+      updates: base.Updates,
+      gradient_step: chex.Array,
+      params: Optional[base.Params]
+  ) -> tuple[chex.Array, chex.ArrayTree]:
+    """Returns true to indicate that updates should be skipped in a multi-step.
+
+    Args:
+      updates: The updates that the gradient transformation has proposed.
+      gradient_step: The current gradient step (see
+        `MultiStepsState.gradient_step`). This can be used for example to reject
+        large gradients with an annealed maximum allowed gradient norm.
+      params: If known, the current params of the function being transformed.
+
+    Returns:
+      A tuple:
+      * First element is an array with a single bool indicating whether or not
+        the updates should be applied.
+      * Second element is an arbitrary py-tree that will be stored in
+        `MultiStepsState.skip_state`. Debugging info can be put here.
+    """
+
+
+def skip_not_finite(
+    updates: base.Updates,
+    gradient_step: chex.Array,
+    params: Optional[base.Params]
+) -> tuple[chex.Array, chex.ArrayTree]:
+  """Returns True iff any of the `updates` contains an inf or a NaN.
+
+  Args:
+    updates: see `ShouldSkipUpdateFunction`.
+    gradient_step: see `ShouldSkipUpdateFunction`.
+    params: see `ShouldSkipUpdateFunction`.
+
+  Returns:
+    A tuple:
+    * First element is a scalar array of type bool.
+    * Second element is a dictionary with keys:
+      - `should_skip`: True iff `updates` contains an inf or a NaN.
+      - `num_not_finite`: total number of inf and NaN found in `updates`.
+  """
+  del gradient_step, params
+  all_is_finite = [jnp.sum(jnp.logical_not(jnp.isfinite(p)))
+                   for p in jtu.tree_leaves(updates)]
+  num_not_finite = jnp.sum(jnp.array(all_is_finite))
+  should_skip = num_not_finite > 0
+  return should_skip, dict(should_skip=should_skip,
+                           num_not_finite=num_not_finite)
+
+
+def skip_large_updates(
+    updates: base.Updates,
+    gradient_step: chex.Array,
+    params: Optional[base.Params],
+    max_squared_norm: float
+) -> tuple[chex.Array, chex.ArrayTree]:
+  """Returns True if the global norm square of `updates` is small enough.
+
+  Args:
+    updates: see `ShouldSkipUpdateFunction`.
+    gradient_step: see `ShouldSkipUpdateFunction`.
+    params: see `ShouldSkipUpdateFunction`.
+    max_squared_norm: max square norm that can be accepted in updates.
+
+  Returns:
+    A tuple:
+    * First element is a scalar array of type bool.
+    * Second element is a dictionary with keys:
+      - `should_skip`: iff ||updates||^2 is greater than `max_squared_norm`.
+      - `norm_squared`: overall norm square of the `updates`.
+  """
+  del gradient_step, params
+  norm_sq = jnp.sum(
+      jnp.array([jnp.sum(p**2) for p in jtu.tree_leaves(updates)]))
+  # This will also return True if `norm_sq` is NaN.
+  should_skip = jnp.logical_not(norm_sq < max_squared_norm)
+  return should_skip, dict(should_skip=should_skip, norm_squared=norm_sq)
+
+
+class MultiStepsState(NamedTuple):
+  """State of the `GradientTransformation` returned by `MultiSteps`.
+
+  Attributes:
+    mini_step: current mini-step counter. At an update, this either increases by
+      1 or is reset to 0.
+    gradient_step: gradient step counter. This only increases after enough
+      mini-steps have been accumulated.
+    inner_opt_state: the state of the wrapped optimiser.
+    acc_grads: accumulated gradients over multiple mini-steps.
+    skip_state: an arbitrarily py tree. This is only relevant when passing
+      a `should_skip_update_fn` to `MultiSteps`.
+  """
+  mini_step: chex.Array
+  gradient_step: chex.Array
+  inner_opt_state: Any
+  acc_grads: Any
+  skip_state: chex.ArrayTree = ()
+
+
+class MultiSteps:
+  """An optimizer wrapper to accumulate gradients over multiple steps.
+
+  This wrapper collects together the updates passed to its ``update`` function
+  over consecutive steps until a given number of scheduled steps is reached.
+  In each of these intermediate steps, the returned value from the optimizer is
+  a tree of zeros of the same shape of the updates passed as input.
+
+  Once the scheduled number of intermediate 'mini-steps' has been reached, the
+  gradients accumulated to the current time will be passed to the wrapped
+  optimizer's update function, (with the inner optimizer's state being updated
+  appropriately) and then returned to the caller. The wrapper's accumulated
+  gradients are then set back to zero and the process starts again.
+
+  The number of mini-steps per gradient update is controlled by a function, and
+  can vary over training, this also allows varying batch size over training.
+  """
+
+  def __init__(
+      self,
+      opt: base.GradientTransformation,
+      every_k_schedule: Union[int, Callable[[chex.Array], chex.Array]],
+      use_grad_mean: bool = True,
+      should_skip_update_fn: Optional[ShouldSkipUpdateFunction] = None):
+    # pylint: disable=line-too-long
+    """Initialiser.
+
+    Args:
+      opt: the wrapped optimizer.
+      every_k_schedule: an int or a function.
+
+        * As a function, it returns how many mini-steps should be accumulated
+          in a single gradient step. Its only argument is the current
+          gradient step count. By varying the returned value, users can vary the
+          overall training batch size.
+        * If an ``int``, this is the constant number of mini-steps per gradient
+          update.
+      use_grad_mean: if ``True`` (the default), gradients accumulated over
+        multiple mini-steps are averaged. Otherwise, they are summed.
+      should_skip_update_fn: if provided, this function is used to decide when
+        to accept or reject the updates from a mini-step. When a mini-step is
+        rejected, the inner state of `MultiSteps` is not updated. In other
+        words, it is as if this mini-step never happened. For example:
+
+        * to ignore updates containing inf or NaN, do
+          ``should_skip_update_fn=skip_not_finite``;
+        * to ignore updates with a norm square larger then 42, do:
+          ``should_skip_update_fn=functools.partial(skip_large_updates, max_norm_sq=42.)``
+
+        Note that the optimizer's state :class:`optax.MultiStepsState` contains
+        a keyword argument ``skip_state`` in which debugging and monitoring
+        information returned by ``should_skip_update_fn`` is written.
+    """
+    # pylint: enable=line-too-long
+    self._opt = base.with_extra_args_support(opt)
+
+    if isinstance(every_k_schedule, int):
+      self._every_k_schedule = lambda step: every_k_schedule
+    else:
+      self._every_k_schedule = every_k_schedule
+    self._use_grad_mean = use_grad_mean
+
+    if self._use_grad_mean:
+      # Use Welford algorithm for numerically stable aggregation of mean.
+      self._acc_update = (
+          lambda grad, acc, *, n_acc: acc + (grad - acc) / (n_acc + 1))
+    else:
+      self._acc_update = lambda grad, acc, *, n_acc: grad + acc
+
+    if should_skip_update_fn is None:
+
+      def should_skip_update_fn(*unused_args, **unused_kwargs):
+        return jnp.array(False, dtype=jnp.bool_), ()
+
+    self._should_skip_update_fn = should_skip_update_fn
+
+  @property
+  def inner_opt(self):
+    return self._opt
+
+  def init(self, params: Any) -> MultiStepsState:
+    """Builds and returns initial `MultiStepsState`."""
+    updates = otu.tree_zeros_like(params)
+    gradient_step = jnp.zeros([], dtype=jnp.int32)
+    _, skip_state = self._should_skip_update_fn(updates, gradient_step, params)
+    init_state = MultiStepsState(
+        mini_step=jnp.zeros([], dtype=jnp.int32),
+        gradient_step=gradient_step,
+        inner_opt_state=self._opt.init(params),
+        acc_grads=updates,
+        skip_state=skip_state)
+    return init_state
+
+  def update(self,
+             updates: base.Updates,
+             state: MultiStepsState,
+             params: Optional[base.Params] = None,
+             **extra_args: Any,
+             ) -> tuple[base.Updates, MultiStepsState]:
+    """Accumulates gradients and proposes non-zero updates every `k_steps`."""
+    k_steps = self._every_k_schedule(state.gradient_step)
+    should_skip_update, skip_state = self._should_skip_update_fn(
+        updates, state.gradient_step, params)
+    if (should_skip_update.dtype, should_skip_update.shape) != (jnp.bool_, ()):
+      raise ValueError(
+          'The `should_skip_update_fn` function should return a boolean scalar '
+          f'array, but it returned an array of dtype {should_skip_update.dtype}'
+          f' and shape {should_skip_update.shape}'
+      )
+
+    # Note: we do not enclose variables to allow JAX to re-use memory buffers.
+    def _do_update(updates, state, params):
+      acc_grads = jtu.tree_map(
+          lambda upd, acc: self._acc_update(upd, acc, n_acc=state.mini_step),
+          updates,
+          state.acc_grads,
+      )
+
+      final_updates, new_inner_state = self._opt.update(
+          acc_grads, state.inner_opt_state, params=params, **extra_args
+      )
+
+      emit = state.mini_step == (k_steps - 1)
+      new_state = MultiStepsState(
+          mini_step=numerics.safe_int32_increment(state.mini_step) % k_steps,
+          gradient_step=emit
+          * numerics.safe_int32_increment(state.gradient_step)
+          + (1 - emit) * state.gradient_step,
+          inner_opt_state=jtu.tree_map(
+              lambda st, nst: jnp.where(emit, nst, st),
+              state.inner_opt_state,
+              new_inner_state,
+          ),
+          acc_grads=jtu.tree_map(
+              lambda ga: (1 - emit) * ga, acc_grads
+          ),
+          skip_state=skip_state,
+      )
+
+      final_updates = jtu.tree_map(
+          lambda ga: emit * ga, final_updates
+      )
+      return final_updates, new_state
+
+    def _skip_update(updates, state, params):
+      del updates, params
+      multi_state_when_skip = MultiStepsState(
+          mini_step=state.mini_step,
+          gradient_step=state.gradient_step,
+          inner_opt_state=state.inner_opt_state,
+          acc_grads=state.acc_grads,
+          skip_state=skip_state,
+      )
+      zero_updates = otu.tree_zeros_like(state.acc_grads)
+      return zero_updates, multi_state_when_skip
+
+    new_updates, new_state = lax.cond(
+        should_skip_update, _skip_update, _do_update, *(updates, state, params)
+    )
+    return new_updates, new_state
+
+  def has_updated(
+      self, state: Union[MultiStepsState, chex.ArrayTree]) -> chex.Array:
+    # Use `getattr` to bypass pytype checks.
+    return jnp.logical_and(
+        getattr(state, 'mini_step') == 0, getattr(state, 'gradient_step') > 0
+    )
+
+  def gradient_transformation(self) -> base.GradientTransformation:
+    return base.GradientTransformation(init=self.init, update=self.update)

testbed/google-deepmind__optax/optax/transforms/_accumulation_test.py

@@ -0,0 +1,298 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for optax.transforms._accumulation."""
+
+from absl.testing import absltest
+import chex
+import flax
+import jax
+import jax.numpy as jnp
+import numpy as np
+
+from optax._src import alias
+from optax._src import combine
+from optax._src import transform
+from optax._src import update
+from optax.transforms import _accumulation
+from optax.transforms import _constraining
+
+
+class AccumulationTest(chex.TestCase):
+
+  @chex.all_variants
+  def test_ema(self):
+    values = jnp.array([5.0, 7.0])
+    decay = 0.9
+    d = decay
+
+    ema = _accumulation.ema(decay=decay, debias=False)
+    state = ema.init(values[0])  # init to zeroes
+
+    transform_fn = self.variant(ema.update)
+    mean, state = transform_fn(values[0], state)
+    np.testing.assert_allclose(mean, (1-d) * values[0], atol=1e-4)
+
+    mean, _ = transform_fn(values[1], state)
+    np.testing.assert_allclose(
+        mean,
+        (1 - d) * (values[1] + d * values[0]), atol=1e-2)
+
+  @chex.all_variants
+  def test_ema_debias(self):
+    values = jnp.array([5.0, 7.0])
+    decay = 0.9
+    d = decay
+
+    ema = _accumulation.ema(decay=decay)
+    state = ema.init(values[0])
+
+    transform_fn = self.variant(ema.update)
+    mean, state = transform_fn(values[0], state)
+    np.testing.assert_allclose(mean, values[0], atol=1e-4)
+
+    mean, state = transform_fn(values[1], state)
+    np.testing.assert_allclose(
+        mean,
+        ((1 - d) * values[1] + d * (1 - d) * values[0]) / (1 - d**2),
+        atol=1e-2)
+    # The state must not be debiased.
+    np.testing.assert_allclose(
+        state.ema,
+        (1 - d) * values[1] + d * (1 - d) * values[0],
+        atol=1e-2)
+
+  def test_skip_not_finite(self):
+    step = jnp.zeros([], dtype=jnp.int32)
+
+    with self.subTest('test_pos_inf'):
+      should_skip, skip_state = _accumulation.skip_not_finite(
+          [jnp.array(float('inf')), jnp.zeros([])], step, None)
+      self.assertTrue(bool(should_skip))
+      self.assertTrue(bool(skip_state['should_skip']))
+      self.assertEqual(int(skip_state['num_not_finite']), 1)
+
+    with self.subTest('test_neg_inf'):
+      should_skip, skip_state = _accumulation.skip_not_finite(
+          [jnp.array(-float('inf')), jnp.zeros([])], step, None)
+      self.assertTrue(bool(should_skip))
+      self.assertTrue(bool(skip_state['should_skip']))
+      self.assertEqual(int(skip_state['num_not_finite']), 1)
+
+    with self.subTest('test_nan'):
+      should_skip, skip_state = _accumulation.skip_not_finite(
+          [jnp.array(float('nan')), jnp.zeros([])], step, None)
+      self.assertTrue(bool(should_skip))
+      self.assertTrue(bool(skip_state['should_skip']))
+      self.assertEqual(int(skip_state['num_not_finite']), 1)
+
+    with self.subTest('test_finite'):
+      should_skip, skip_state = _accumulation.skip_not_finite(
+          [jnp.array(11.), jnp.zeros([])], step, None)
+      self.assertFalse(bool(should_skip))
+      self.assertFalse(bool(skip_state['should_skip']))
+      self.assertEqual(int(skip_state['num_not_finite']), 0)
+
+  def test_skip_large_updates(self):
+    step = jnp.zeros([], dtype=jnp.int32)
+
+    with self.subTest('test_inf'):
+      should_skip, skip_state = _accumulation.skip_large_updates(
+          [jnp.array(float('inf')), jnp.zeros([])], step, None, 100.)
+      self.assertTrue(bool(should_skip))
+      self.assertTrue(bool(skip_state['should_skip']))
+      self.assertEqual(float(skip_state['norm_squared']), float('inf'))
+
+    with self.subTest('test_nan'):
+      should_skip, skip_state = _accumulation.skip_large_updates(
+          [jnp.array(float('nan')), jnp.zeros([])], step, None, 100.)
+      self.assertTrue(bool(should_skip))
+      self.assertTrue(bool(skip_state['should_skip']))
+      # Recall that NaN != NaN.
+      norm_squared = float(skip_state['norm_squared'])
+      self.assertNotEqual(norm_squared, norm_squared)
+
+    with self.subTest('test_large'):
+      should_skip, skip_state = _accumulation.skip_large_updates(
+          [jnp.array(11.), jnp.zeros([])], step, None, 100.)
+      self.assertTrue(bool(should_skip))
+      self.assertTrue(bool(skip_state['should_skip']))
+      self.assertEqual(float(skip_state['norm_squared']), 121.)
+
+    with self.subTest('test_small'):
+      should_skip, skip_state = _accumulation.skip_large_updates(
+          [jnp.zeros([]), jnp.zeros([])], step, None, 100.)
+      self.assertFalse(bool(should_skip))
+      self.assertFalse(bool(skip_state['should_skip']))
+      self.assertEqual(float(skip_state['norm_squared']), 0.)
+
+  @chex.variants(with_jit=True, without_jit=True, with_pmap=True)
+  def test_multi_steps(self):
+    batch_size = 32
+    x_size = 7
+    # Parameters should be updated only every `k_steps` optimisation steps.
+    k_steps = 4
+    data = jnp.ones([batch_size, x_size])
+
+    class Loss(flax.linen.Module):
+      @flax.linen.compact
+      def __call__(self, x):
+        return jnp.sum(flax.linen.Dense(10)(x)**2)
+
+    loss = Loss()
+
+    params = loss.init({'params': jax.random.PRNGKey(0)}, data)['params']
+
+    def loss_apply(params, data):
+      return loss.apply({'params': params}, data)
+
+    ms_opt = _accumulation.MultiSteps(
+        # Use a non-trivial inner optimiser:
+        # * it has a state,
+        # * it requires the params for the update.
+        combine.chain(transform.scale_by_adam(),
+                      transform.add_decayed_weights(1e-2),
+                      transform.scale(-1e-4)), k_steps)
+
+    opt_init, opt_update = ms_opt.gradient_transformation()
+
+    # Put the training in one function, to check that the update is indeed
+    # jittable.
+    def train_step(data, opt_state, params):
+      grad = jax.grad(loss_apply)(params, data)
+      updates, opt_state = opt_update(grad, opt_state, params)
+      return updates, opt_state
+
+    opt_state = opt_init(params)
+
+    prev_loss = loss_apply(params, data)
+    for idx in range(5 * k_steps):
+      updates, opt_state = self.variant(train_step)(data, opt_state, params)
+      new_params = update.apply_updates(params, updates)
+      new_loss = loss_apply(new_params, data)
+      if idx % k_steps < k_steps - 1:
+        # The parameters should not have changed and the loss should be
+        # constant.
+        jax.tree_util.tree_map(
+            np.testing.assert_array_equal, new_params, params)
+        np.testing.assert_equal(new_loss, prev_loss)
+        self.assertFalse(ms_opt.has_updated(opt_state))
+      else:
+        # This is a step where parameters should actually have been updated, and
+        # the loss should accordingly go down.
+        np.testing.assert_array_less(new_loss, prev_loss)
+        prev_loss = new_loss
+        self.assertTrue(ms_opt.has_updated(opt_state))
+      params = new_params
+
+  def test_multi_steps_every_k_schedule(self):
+    # Test a non-trivial schedule which varies over time.
+    ms_opt = _accumulation.MultiSteps(
+        alias.sgd(1e-4), lambda grad_step: jnp.where(grad_step < 2, 1, 3))
+    opt_init, opt_update = ms_opt.gradient_transformation()
+    params = dict(a=jnp.zeros([]))
+    opt_state = opt_init(params)
+    grad = dict(a=jnp.zeros([]))
+    self.assertFalse(ms_opt.has_updated(opt_state))
+    # First two steps have 1 mini-step per update.
+    for _ in range(2):
+      _, opt_state = opt_update(grad, opt_state, params)
+      self.assertTrue(ms_opt.has_updated(opt_state))
+    # Subsequently, mini-steps should have 3 mini-steps per update.
+    for _ in range(5):
+      for _ in range(2):
+        _, opt_state = opt_update(grad, opt_state, params)
+        self.assertFalse(ms_opt.has_updated(opt_state))
+      _, opt_state = opt_update(grad, opt_state, params)
+      self.assertTrue(ms_opt.has_updated(opt_state))
+
+  def test_multi_steps_zero_nans(self):
+    # Test that MultiStep is compatible with zero_nans
+    # https://github.com/google-deepmind/optax/issues/828
+    ms_opt = _accumulation.MultiSteps(
+        combine.chain(_constraining.zero_nans(), alias.sgd(1e-4)),
+        every_k_schedule=2
+    )
+    opt_init, opt_update = ms_opt.gradient_transformation()
+    params = dict(a=jnp.zeros([]))
+    opt_state = opt_init(params)
+    grad = dict(a=jnp.zeros([]))
+    opt_update(grad, opt_state, params)
+
+  def test_multi_steps_computes_mean(self):
+    k_steps = 4
+    ms_opt = _accumulation.MultiSteps(
+        transform.scale(1.0), k_steps, use_grad_mean=True)
+    opt_init, opt_update = ms_opt.gradient_transformation()
+    params = dict(a=jnp.zeros([]))
+    opt_state = opt_init(params)
+    grads = [dict(a=jnp.ones([]) * i) for i in [1, 2, 3, 4]]
+    self.assertFalse(ms_opt.has_updated(opt_state))
+
+    # First 3 steps don't update.
+    for grad in grads[:-1]:
+      _, opt_state = opt_update(grad, opt_state, params)
+      self.assertFalse(ms_opt.has_updated(opt_state))
+
+    # Actual update.
+    new_params, opt_state = opt_update(grads[-1], opt_state, params)
+    self.assertTrue(ms_opt.has_updated(opt_state))
+    np.testing.assert_array_equal(new_params['a'], 2.5)
+
+  def test_multi_steps_skip_not_finite(self):
+    k_steps = 2
+    ms_opt = _accumulation.MultiSteps(
+        alias.sgd(1.), k_steps,
+        should_skip_update_fn=_accumulation.skip_not_finite)
+    opt_init, opt_update = ms_opt.gradient_transformation()
+    opt_init = jax.jit(opt_init)
+    opt_update = jax.jit(opt_update)
+    params = dict(a=jnp.zeros([]))
+    opt_state = opt_init(params)
+
+    with self.subTest('test_good_updates'):
+      updates, opt_state = opt_update(dict(a=jnp.ones([])), opt_state, params)
+      self.assertEqual(int(opt_state.mini_step), 1)
+      params = update.apply_updates(params, updates)
+      updates, opt_state = opt_update(dict(a=jnp.ones([])), opt_state, params)
+      self.assertEqual(int(opt_state.mini_step), 0)
+      params = update.apply_updates(params, updates)
+      np.testing.assert_array_equal(params['a'], jnp.negative(jnp.ones([])))
+
+    with self.subTest('test_inf_updates'):
+      updates, opt_state = opt_update(
+          dict(a=jnp.array(float('inf'))), opt_state, params)
+      self.assertEqual(int(opt_state.mini_step), 0)  # No increase in mini_step
+      params = update.apply_updates(params, updates)
+      np.testing.assert_array_equal(params['a'], jnp.negative(jnp.ones([])))
+
+    with self.subTest('test_nan_updates'):
+      updates, opt_state = opt_update(
+          dict(a=jnp.full([], float('nan'))), opt_state, params)
+      self.assertEqual(int(opt_state.mini_step), 0)  # No increase in mini_step
+      params = update.apply_updates(params, updates)
+      np.testing.assert_array_equal(params['a'], jnp.negative(jnp.ones([])))
+
+    with self.subTest('test_final_good_updates'):
+      updates, opt_state = opt_update(dict(a=jnp.ones([])), opt_state, params)
+      self.assertEqual(int(opt_state.mini_step), 1)
+      params = update.apply_updates(params, updates)
+      updates, opt_state = opt_update(dict(a=jnp.ones([])), opt_state, params)
+      self.assertEqual(int(opt_state.mini_step), 0)
+      params = update.apply_updates(params, updates)
+      np.testing.assert_array_equal(params['a'], jnp.negative(jnp.full([], 2.)))
+
+
+if __name__ == '__main__':
+  absltest.main()

testbed/google-deepmind__optax/optax/transforms/_adding.py

@@ -0,0 +1,105 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Additive components in gradient transformations."""
+
+from typing import Any, Callable, NamedTuple, Optional, Union
+
+import chex
+import jax
+from jax import tree_util as jtu
+import jax.numpy as jnp
+
+from optax import tree_utils as otu
+from optax._src import base
+from optax._src import numerics
+from optax._src import wrappers
+
+
+def add_decayed_weights(
+    weight_decay: Union[float, jax.Array] = 0.0,
+    mask: Optional[Union[Any, Callable[[base.Params], Any]]] = None
+) -> base.GradientTransformation:
+  """Add parameter scaled by `weight_decay`.
+
+  Args:
+    weight_decay: A scalar weight decay rate.
+    mask: A tree with same structure as (or a prefix of) the params PyTree,
+      or a Callable that returns such a pytree given the params/updates.
+      The leaves should be booleans, `True` for leaves/subtrees you want to
+      apply the transformation to, and `False` for those you want to skip.
+
+  Returns:
+    A `GradientTransformation` object.
+  """
+
+  def update_fn(updates, state, params):
+    if params is None:
+      raise ValueError(base.NO_PARAMS_MSG)
+    updates = jtu.tree_map(
+        lambda g, p: g + weight_decay * p, updates, params)
+    return updates, state
+
+  # If mask is not `None`, apply mask to the gradient transformation.
+  # E.g. it is common to skip weight decay on bias units and batch stats.
+  if mask is not None:
+    return wrappers.masked(
+        base.GradientTransformation(base.init_empty_state, update_fn), mask)
+  return base.GradientTransformation(base.init_empty_state, update_fn)
+
+
+class AddNoiseState(NamedTuple):
+  """State for adding gradient noise. Contains a count for annealing."""
+  count: chex.Array
+  rng_key: chex.PRNGKey
+
+
+def add_noise(
+    eta: float,
+    gamma: float,
+    seed: int
+) -> base.GradientTransformation:
+  """Add gradient noise.
+
+  References:
+    [Neelakantan et al, 2014](https://arxiv.org/abs/1511.06807)
+
+  Args:
+    eta: Base variance of the gaussian noise added to the gradient.
+    gamma: Decay exponent for annealing of the variance.
+    seed: Seed for random number generation.
+
+  Returns:
+    A `GradientTransformation` object.
+  """
+
+  def init_fn(params):
+    del params
+    return AddNoiseState(
+        count=jnp.zeros([], jnp.int32),
+        rng_key=jax.random.PRNGKey(seed))
+
+  def update_fn(updates, state, params=None):  # pylint: disable=missing-docstring
+    del params
+    count_inc = numerics.safe_int32_increment(state.count)
+    standard_deviation = jnp.sqrt(eta / count_inc**gamma)
+
+    rng_key, sample_key = jax.random.split(state.rng_key)
+    noise = otu.tree_random_like(
+        sample_key, target_tree=updates, sampler=jax.random.normal)
+    updates = otu.tree_add_scalar_mul(
+        tree_x=updates, scalar=standard_deviation, tree_y=noise)
+    return updates, AddNoiseState(count=count_inc, rng_key=rng_key)
+
+  return base.GradientTransformation(init_fn, update_fn)

testbed/google-deepmind__optax/optax/transforms/_adding_test.py

@@ -0,0 +1,96 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for optax.transforms._adding."""
+
+from absl.testing import absltest
+
+import chex
+from jax import tree_util as jtu
+import jax.numpy as jnp
+
+from optax.transforms import _adding
+
+STEPS = 50
+
+
+class AddingTest(chex.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    self.init_params = (jnp.array([1., 2.]), jnp.array([3., 4.]))
+    self.per_step_updates = (jnp.array([500., 5.]), jnp.array([300., 3.]))
+
+  @chex.all_variants
+  def test_add_decayed_weights(self):
+    # Define a transform that add decayed weights.
+    # We can define a mask either as a pytree, or as a function that
+    # returns the pytree. Below we define the pytree directly.
+    mask = (True, dict(a=True, b=False))
+    tx = _adding.add_decayed_weights(0.1, mask=mask)
+    # Define input updates and weights.
+    updates = (
+        jnp.zeros((2,), dtype=jnp.float32),
+        dict(
+            a=jnp.zeros((2,), dtype=jnp.float32),
+            b=jnp.zeros((2,), dtype=jnp.float32),))
+    weights = (
+        jnp.ones((2,), dtype=jnp.float32),
+        dict(
+            a=jnp.ones((2,), dtype=jnp.float32),
+            b=jnp.ones((2,), dtype=jnp.float32),))
+    # This mask means that we will add decayed weights to the first two
+    # terms in the input updates, but not to the last element.
+    expected_tx_updates = (
+        0.1*jnp.ones((2,), dtype=jnp.float32),
+        dict(
+            a=0.1*jnp.ones((2,), dtype=jnp.float32),
+            b=jnp.zeros((2,), dtype=jnp.float32),))
+    # Apply transform
+    state = tx.init(weights)
+    transform_fn = self.variant(tx.update)
+    new_updates, _ = transform_fn(updates, state, weights)
+    # Assert output as expected.
+    chex.assert_trees_all_close(new_updates, expected_tx_updates)
+
+  @chex.all_variants
+  def test_add_noise_has_correct_variance_scaling(self):
+    # Prepare to compare noise with a rescaled unit-variance substitute.
+    eta = 0.3
+    gamma = 0.55
+    seed = 314
+    noise = _adding.add_noise(eta, gamma, seed)
+    noise_unit = _adding.add_noise(1.0, 0.0, seed)
+
+    params = self.init_params
+    state = noise.init(params)
+    state_unit = noise_unit.init(params)
+
+    # Check the noise itself by adding it to zeros.
+    updates = jtu.tree_map(jnp.zeros_like, params)
+
+    for i in range(1, STEPS + 1):
+      updates_i, state = self.variant(noise.update)(updates, state)
+      updates_i_unit, state_unit = noise_unit.update(updates, state_unit)
+
+      scale = jnp.sqrt(eta / i**gamma)
+
+      updates_i_rescaled = jtu.tree_map(
+          lambda g, s=scale: g * s, updates_i_unit)
+
+      chex.assert_trees_all_close(updates_i, updates_i_rescaled, rtol=1e-4)
+
+
+if __name__ == "__main__":
+  absltest.main()

testbed/google-deepmind__optax/optax/transforms/_clipping.py

@@ -0,0 +1,282 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Gradient clipping transformations.
+
+Note that complex numbers are also supported, see
+https://gist.github.com/wdphy16/118aef6fb5f82c49790d7678cf87da29
+"""
+
+import chex
+import jax
+from jax import tree_util as jtu
+import jax.numpy as jnp
+
+from optax import tree_utils as otu
+from optax._src import base
+from optax._src import linear_algebra
+from optax._src import numerics
+
+
+def clip(max_delta: chex.Numeric) -> base.GradientTransformation:
+  """Clips updates element-wise, to be in ``[-max_delta, +max_delta]``.
+
+  Args:
+    max_delta: The maximum absolute value for each element in the update.
+
+  Returns:
+    A `GradientTransformation` object.
+  """
+
+  def update_fn(updates, state, params=None):
+    del params
+    return otu.tree_clip(updates, -max_delta, max_delta), state
+
+  return base.GradientTransformation(base.init_empty_state, update_fn)
+
+
+def clip_by_block_rms(threshold: float) -> base.GradientTransformation:
+  """Clips updates to a max rms for the gradient of each param vector or matrix.
+
+  A `block` is here a weight vector (e.g. in a Linear layer) or a weight matrix
+  (e.g. in a convolutional layer) appearing as a leaf in the grads/param pytree.
+
+  Args:
+    threshold: The maximum rms for the gradient of each param vector or matrix.
+
+  Returns:
+    A `GradientTransformation` object.
+  """
+
+  def update_fn(updates, state, params=None):
+    del params
+
+    def _clip_fn(u):
+      clip_denom = jnp.maximum(
+          1.0,
+          jnp.sqrt(jnp.mean(numerics.abs_sq(u))) / threshold)
+      return u / clip_denom
+
+    updates = jtu.tree_map(_clip_fn, updates)
+    return updates, state
+
+  return base.GradientTransformation(base.init_empty_state, update_fn)
+
+
+def clip_by_global_norm(max_norm: float) -> base.GradientTransformation:
+  """Clips updates using their global norm.
+
+  References:
+    [Pascanu et al, 2012](https://arxiv.org/abs/1211.5063)
+
+  Args:
+    max_norm: The maximum global norm for an update.
+
+  Returns:
+    A `GradientTransformation` object.
+  """
+
+  def update_fn(updates, state, params=None):
+    del params
+    g_norm = linear_algebra.global_norm(updates)
+    # TODO(b/163995078): revert back to the following (faster) implementation
+    # once analysed how it affects backprop through update (e.g. meta-gradients)
+    # g_norm = jnp.maximum(max_norm, g_norm)
+    # updates = jtu.tree_map(lambda t: (t / g_norm) * max_norm, updates)
+    trigger = jnp.squeeze(g_norm < max_norm)
+    chex.assert_shape(trigger, ())  # A scalar.
+
+    def clip_fn(t):
+      return jax.lax.select(trigger, t, (t / g_norm.astype(t.dtype)) * max_norm)
+
+    updates = jtu.tree_map(clip_fn, updates)
+    return updates, state
+
+  return base.GradientTransformation(base.init_empty_state, update_fn)
+
+
+def per_example_global_norm_clip(
+    grads: list[chex.Array], l2_norm_clip: float
+) -> tuple[list[chex.Array], jax.Array]:
+  """Applies gradient clipping per-example using their global norm.
+
+  References:
+    [Abadi et al, 2016](https://arxiv.org/abs/1607.00133)
+
+  Args:
+    grads: flattened update; the function expects these to have a batch
+      dimension on the 0th axis.
+    l2_norm_clip: maximum L2 norm of the per-example gradients.
+
+  Returns:
+    A tuple containing sum of the clipped per-example grads, and the number of
+    per-example grads that were clipped.
+  """
+  bsize = grads[0].shape[0]
+
+  if any(g.ndim == 0 or bsize != g.shape[0] for g in grads):
+    raise ValueError(
+        'Unlike other transforms, `per_example_global_norm_clip` expects'
+        ' `grads` to have a batch dimension in the 0th axis.')
+
+  global_grad_norms = jax.vmap(linear_algebra.global_norm)(grads)
+  divisors = jnp.maximum(global_grad_norms / l2_norm_clip, 1.0)
+  num_clipped = jnp.greater(divisors, 1.0).sum()
+  clipped_sum = [(jnp.moveaxis(g, 0, -1) / divisors).sum(-1) for g in grads]
+  return clipped_sum, num_clipped
+
+
+def per_example_layer_norm_clip(
+    grads: list[chex.Array],
+    global_l2_norm_clip: float,
+    uniform: bool = True,
+    eps: float = 1e-8,
+) -> tuple[list[chex.Array], list[chex.Array]]:
+  """Applies gradient clipping per-example using per-layer norms.
+
+  References:
+    [McMahan et al, 2012](https://arxiv.org/abs/1710.06963)]
+
+  Args:
+    grads: flattened update; i.e. a list of gradients in which each item is
+      the gradient for one layer; the function expects these to have a batch
+      dimension on the 0th axis.
+    global_l2_norm_clip: overall L2 clip norm to use.
+    uniform: If `True`, per-layer clip norm is global_l2_norm_clip/sqrt(L),
+      where L is the number of layers. Otherwise, per-layer clip norm is
+      global_l2_norm_clip * sqrt(f), where f is the fraction of total model
+      parameters that are in this layer.
+    eps: Small positive value to add to norms to avoid possible division by
+      zero.
+
+  Let C = `global_l2_norm_clip value`. Then per-layer clipping is done as
+  follows:
+  (1) If `uniform` is `True`, each of the K layers has an individual clip
+      norm of C / sqrt(K).
+  (2) If `uniform` is `False`, each of the K layers has an individual clip
+      norm of C * sqrt(D_i / D) where D_i is the number of parameters in
+      layer i, and D is the total number of parameters in the model.
+
+  Returns:
+    A tuple containing sum of the clipped per-example grads and the number of
+    per-example grads that were clipped for each layer.
+  """
+  bsize = grads[0].shape[0]
+
+  if any(g.ndim == 0 or bsize != g.shape[0] for g in grads):
+    raise ValueError(
+        'Unlike other transforms, `per_example_layer_norm_clip` expects'
+        ' `grads` to have a batch dimension in the 0th axis; got shapes:'
+        f' {(g.shape for g in grads)}.'
+    )
+
+  num_layers = len(grads)
+
+  # Compute per-layer clip norms, based on whether we are using uniform
+  # variant or not.
+  if uniform:
+    # Create list of length `num_layers` of per-layer clip norm.
+    layer_clip_norms = (
+        global_l2_norm_clip * (1.0 / num_layers) ** 0.5,
+    ) * num_layers
+  else:
+    total_params = sum(g[0].size for g in grads)
+    layer_clip_norms = tuple(
+        global_l2_norm_clip * (g[0].size / float(total_params)) ** 0.5
+        for g in grads
+    )
+
+  # Compute per-layer grad norms.
+  def map_layer_norm(grads_list):
+    return [jnp.linalg.norm(g, ord=None, axis=None) for g in grads_list]
+
+  layer_grad_norms_per_example = jax.vmap(map_layer_norm)(grads)
+
+  # Perform clipping.
+  divisors = (
+      tuple(
+          jnp.maximum(
+              layer_grad_norm / (layer_clip_norm + eps), 1.0
+          )
+          for layer_grad_norm, layer_clip_norm in zip(
+              layer_grad_norms_per_example, layer_clip_norms
+          )
+      )
+  )
+  num_clipped = [jnp.greater(divisor, 1.0).sum() for divisor in divisors]
+  clipped_sum = [
+      (g / jnp.expand_dims(d, axis=[i for i in range(1, g.ndim)])).sum(0)
+      for g, d in zip(grads, divisors)
+  ]
+  return clipped_sum, num_clipped
+
+
+def unitwise_norm(x: chex.Array) -> chex.Array:
+  """Computes norms of each output unit separately."""
+  if jnp.squeeze(x).ndim <= 1:  # Scalars and vectors
+    squared_norm = jnp.sum(numerics.abs_sq(x), keepdims=True)
+  # Note that this assumes parameters with a shape of length 3 are multihead
+  # linear parameters--if you wish to apply AGC to 1D convs, you may need
+  # to modify this line.
+  elif x.ndim in (2, 3):  # Linear layers of shape IO or multihead linear
+    squared_norm = jnp.sum(numerics.abs_sq(x), axis=0, keepdims=True)
+  elif x.ndim == 4:  # Conv kernels of shape HWIO
+    squared_norm = jnp.sum(numerics.abs_sq(x), axis=(0, 1, 2), keepdims=True)
+  else:
+    raise ValueError(
+        f'Expected parameter with shape in {1, 2, 3, 4}, got {x.shape}.')
+  chex.assert_is_broadcastable(squared_norm.shape, x.shape)
+  return jnp.broadcast_to(jnp.sqrt(squared_norm), x.shape)
+
+
+def unitwise_clip(g_norm: chex.Array,
+                  max_norm: chex.Array,
+                  grad: chex.Array,
+                  div_eps: float = 1e-6) -> chex.Array:
+  """Applies gradient clipping unit-wise."""
+  # This little max(., div_eps) is distinct from the normal eps and just
+  # prevents division by zero. It technically should be impossible to engage.
+  clipped_grad = grad * (max_norm / jnp.maximum(g_norm, div_eps))
+  chex.assert_equal_shape((g_norm, max_norm, grad, clipped_grad))
+  return jnp.where(g_norm < max_norm, grad, clipped_grad)
+
+
+def adaptive_grad_clip(clipping: float,
+                       eps: float = 1e-3) -> base.GradientTransformation:
+  """Clips updates to be at most ``clipping * parameter_norm``, unit-wise.
+
+  References:
+    [Brock, Smith, De, Simonyan 2021] High-Performance Large-Scale Image
+    Recognition Without Normalization. (https://arxiv.org/abs/2102.06171)
+
+  Args:
+    clipping: The maximum allowed ratio of update norm to parameter norm.
+    eps: An epsilon term to prevent clipping of zero-initialized params.
+
+  Returns:
+    A `GradientTransformation` object.
+  """
+
+  def update_fn(updates, state, params):
+    if params is None:
+      raise ValueError(base.NO_PARAMS_MSG)
+    g_norm, p_norm = jtu.tree_map(unitwise_norm, (updates, params))
+    # Maximum allowable norm.
+    max_norm = jtu.tree_map(
+        lambda x: clipping * jnp.maximum(x, eps), p_norm)
+    # If grad norm > clipping * param_norm, rescale.
+    updates = jtu.tree_map(unitwise_clip, g_norm, max_norm, updates)
+    return updates, state
+
+  return base.GradientTransformation(base.init_empty_state, update_fn)

testbed/google-deepmind__optax/optax/transforms/_clipping_test.py

@@ -0,0 +1,143 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for optax.transforms._clipping."""
+
+from absl.testing import absltest
+import chex
+import jax
+import jax.numpy as jnp
+
+from optax._src import linear_algebra
+from optax.transforms import _clipping
+
+
+STEPS = 50
+LR = 1e-2
+
+
+class ClippingTest(absltest.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    self.init_params = (jnp.array([1., 2.]), jnp.array([3., 4.]))
+    self.per_step_updates = (jnp.array([500., 5.]), jnp.array([300., 3.]))
+
+  def test_clip(self):
+    updates = self.per_step_updates
+    # For a sufficiently high delta the update should not be changed.
+    clipper = _clipping.clip(1e6)
+    clipped_updates, _ = clipper.update(updates, None)
+    chex.assert_trees_all_close(clipped_updates, clipped_updates)
+    # Clipping at delta=1 should make all updates exactly 1.
+    clipper = _clipping.clip(1.)
+    clipped_updates, _ = clipper.update(updates, None)
+    chex.assert_trees_all_close(
+        clipped_updates, jax.tree_util.tree_map(jnp.ones_like, updates))
+
+  def test_clip_by_block_rms(self):
+    rmf_fn = lambda t: jnp.sqrt(jnp.mean(t**2))
+    updates = self.per_step_updates
+    for i in range(1, STEPS + 1):
+      clipper = _clipping.clip_by_block_rms(1. / i)
+      # Check that the clipper actually works and block rms is <= threshold
+      updates, _ = clipper.update(updates, None)
+      self.assertAlmostEqual(rmf_fn(updates[0]), 1. / i)
+      self.assertAlmostEqual(rmf_fn(updates[1]), 1. / i)
+      # Check that continuously clipping won't cause numerical issues.
+      updates_step, _ = clipper.update(self.per_step_updates, None)
+      chex.assert_trees_all_close(updates, updates_step)
+
+  def test_clip_by_global_norm(self):
+    updates = self.per_step_updates
+    for i in range(1, STEPS + 1):
+      clipper = _clipping.clip_by_global_norm(1. / i)
+      # Check that the clipper actually works and global norm is <= max_norm
+      updates, _ = clipper.update(updates, None)
+      self.assertAlmostEqual(
+          linear_algebra.global_norm(updates), 1. / i, places=6)
+      # Check that continuously clipping won't cause numerical issues.
+      updates_step, _ = clipper.update(self.per_step_updates, None)
+      chex.assert_trees_all_close(updates, updates_step)
+
+  def test_adaptive_grad_clip(self):
+    updates = self.per_step_updates
+    params = self.init_params
+    for i in range(1, STEPS + 1):
+      clip_r = 1. / i
+      clipper = _clipping.adaptive_grad_clip(clip_r)
+
+      # Check that the clipper actually works and upd_norm is < c * param_norm.
+      updates, _ = clipper.update(updates, None, params)
+      u_norm, p_norm = jax.tree_util.tree_map(
+          _clipping.unitwise_norm, (updates, params))
+      cmp = jax.tree_util.tree_map(
+          lambda u, p, c=clip_r: u - c * p < 1e-6, u_norm, p_norm)
+      for leaf in jax.tree_util.tree_leaves(cmp):
+        self.assertTrue(leaf.all())
+
+      # Check that continuously clipping won't cause numerical issues.
+      updates_step, _ = clipper.update(self.per_step_updates, None, params)
+      chex.assert_trees_all_close(updates, updates_step)
+
+  def test_per_example_layer_norm_clip(self):
+    # Test data for a model with two layers and a batch size of 4. The
+    # 0th layer has one parameter (shape (1)), and the 1st layer has shape
+    # (3, 3, 2).
+    grads_flat = [
+        jnp.array([[0.5], [1.5], [-2.0], [3.0]]),
+        jnp.ones([4, 3, 3, 2], dtype=jnp.float32),
+    ]
+
+    with self.subTest(name='Uniform Variant'):
+      sum_clipped_grads, num_clipped = _clipping.per_example_layer_norm_clip(
+          grads_flat, global_l2_norm_clip=jnp.sqrt(2), uniform=True
+      )
+
+      # For the uniform variant, with global_l2_norm_clip=sqrt(2), the per-layer
+      # clip norm is 1.0. Thus the per-example per-layer clipped grads are
+      # [[0.5], [1.0], [-1.0], [1.0]] and [1 / sqrt(18) ... ]. The sum of
+      # these over the 4 input gradients are [1.5] and [4 / sqrt(18) ...].
+      self.assertAlmostEqual(sum_clipped_grads[0], 1.5)
+      for element in sum_clipped_grads[1].flatten():
+        self.assertAlmostEqual(element, 4 / jnp.sqrt(18), places=4)
+
+      # The three values in grads_flat[0] with magnitude > 1.0 are clipped, as
+      # are all four values in grads_flat[1].
+      self.assertEqual(num_clipped[0], 3)
+      self.assertEqual(num_clipped[1], 4)
+
+    with self.subTest(name='Scaled Variant'):
+      sum_clipped_grads, num_clipped = _clipping.per_example_layer_norm_clip(
+          grads_flat, global_l2_norm_clip=jnp.sqrt(19), uniform=False
+      )
+
+      # For the scaled variant, with global_l2_norm_clip=sqrt(19), the per-layer
+      # clip norm for the 0th layer is 1.0, and the per-layer clip norm for
+      # the 1st layer is sqrt(18). Thus the per-example per-layer clipped grads
+      # are [[0.5], [1.0], [-1.0], [1.0]] and [[1.0)] ... ]. The sum of
+      # these over the 4 input gradients are [1.5] and [4.0 ...].
+      self.assertAlmostEqual(sum_clipped_grads[0], 1.5)
+      for element in sum_clipped_grads[1].flatten():
+        self.assertAlmostEqual(element, 4.0)
+
+      # The three values in grads_flat[0] with magnitude > 1.0 are clipped. The
+      # grad norms for grads_flat[1] are all equal to the per-layer clip norm,
+      # so none of these grads are clipped.
+      self.assertEqual(num_clipped[0], 3)
+      self.assertEqual(num_clipped[1], 0)
+
+
+if __name__ == '__main__':
+  absltest.main()

testbed/google-deepmind__optax/optax/transforms/_combining.py

@@ -0,0 +1,255 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Flexibly compose gradient transformations."""
+
+from typing import Callable, NamedTuple, Union, Mapping, Hashable
+
+import jax
+
+from optax._src import base
+from optax._src import wrappers
+
+
+def chain(
+    *args: base.GradientTransformation,
+) -> base.GradientTransformationExtraArgs:
+  """Applies a list of chainable update transformations.
+
+  This function creates a new :func:`optax.GradientTransformation` that applies
+  a sequence of gradient transformations in order. The ``init`` function of the
+  new transformation constructs the optimizer state by concatenating the states
+  of the individual transforms, while the ``update`` function applies the
+  updates in the given order.
+
+  Examples:
+
+    A transform that scales by -0.1 the adam update:
+
+      >>> import optax
+      >>> transform1 = optax.scale_by_adam()
+      >>> transform2 = optax.scale(-0.1)
+      >>> chained_transform = optax.chain(transform1, transform2)
+      >>> params = {'a': 1.0}
+      >>> state = chained_transform.init(params)
+      >>> updates = {'a': -0.5}
+      >>> updates, new_state = chained_transform.update(updates, state, params)
+
+  Args:
+    *args: a sequence of chainable (init_fn, update_fn) tuples.
+
+  Returns:
+    A :func:`GradientTransformationExtraArgs`, created by chaining the input
+    transformations. Note that independent of the argument types, the resulting
+    transformation always supports extra args. Any extra arguments passed to the
+    returned transformation will be passed only to those transformations in the
+    chain that support extra args.
+  """
+
+  transforms = [base.with_extra_args_support(t) for t in args]
+  init_fns, update_fns = zip(*transforms)
+
+  def init_fn(params):
+    return tuple(fn(params) for fn in init_fns)
+
+  def update_fn(updates, state, params=None, **extra_args):
+    if len(update_fns) != len(state):
+      raise ValueError('The number of updates and states has to be the same in '
+                       'chain! Make sure you have called init first!')
+
+    new_state = []
+    for s, fn in zip(state, update_fns):
+      updates, new_s = fn(updates, s, params, **extra_args)
+      new_state.append(new_s)
+    return updates, tuple(new_state)
+
+  # We opt to always return the GradientTransformationExtraArgs type here,
+  # instead of selecting the return type based on the arguments, since it works
+  # much better with the currently available type checkers. It also means that
+  # users will not get unexpected signature errors if they remove all of the
+  # transformations in a chain accepting extra args.
+  return base.GradientTransformationExtraArgs(init_fn, update_fn)
+
+
+def named_chain(
+    *transforms: tuple[str, base.GradientTransformation]
+) -> base.GradientTransformationExtraArgs:
+  """Chains optax gradient transformations.
+
+  A variant of :func:`optax.chain` that allows to name each transformation.
+
+  Here the ``transforms`` are ``(name, transformation)`` pairs, constituted of a
+  string ``name`` and an associated transformation ``transformation``. The
+  gradient transformation must be an instance of :func:`GradientTransformation`
+  or :func:`GradientTransformationExtraArgs`.
+
+  Each ``name`` is used as key for the state of the corresponding transformation
+  within the ``named_chain`` state. Thus the state of the transformation
+  with a given ``name`` can be easily retrieved as ``opt_state[name]``.
+
+  Examples:
+
+    >>> # tx1 is a GradientTransformation with no extra_args. 
+    >>> # tx2 is a GradientTransformationExtraArgs that requires `loss`.
+    >>> # tx3 is a GradientTransformationExtraArgs that requires `temperature`.
+    >>> tx = named_chain(('one', tx1), ('two', tx2), ('three', tx3))
+    >>> extra_args={'loss': 0.3, 'temperature': 0.01}
+    >>> tx.init(params)
+    >>> tx.update(grads, state, params, **extra_args)
+
+  Args:
+    *transforms: an arbitrary number of ``(name, tx)`` pairs, constituted of a
+      string ``name`` and an associated transformation ``tx``. The latter is a
+      :func:`GradientTransformation` or :func:`GradientTransformationExtraArgs`.
+
+  Returns: 
+    A single (init_fn, update_fn) tuple. 
+  """
+
+  names = [name for name, _ in transforms]
+
+  if len(names) != len(set(names)):
+    raise ValueError(
+        f'Named transformations must have unique names, but got {names}')
+
+  transforms = [
+      (name, base.with_extra_args_support(t))
+      for name, t in transforms]
+
+  def init_fn(params):
+    states = {}
+    for (name, tx) in transforms:
+      states[name] = tx.init(params)
+    return states
+  def update_fn(updates, state, params=None, **extra_args):
+    new_state = {}
+    for (name, tx) in transforms:
+      updates, new_state[name] = tx.update(
+          updates, state[name], params, **extra_args)
+    return updates, new_state
+
+  return base.GradientTransformationExtraArgs(init_fn, update_fn)
+
+
+class PartitionState(NamedTuple):
+  inner_states: Mapping[Hashable, base.OptState]
+
+
+def partition(
+    transforms: Mapping[Hashable, base.GradientTransformation],
+    param_labels: Union[base.PyTree, Callable[[base.PyTree], base.PyTree]],
+    *,
+    mask_compatible_extra_args: bool = False,
+) -> base.GradientTransformationExtraArgs:
+  """Partitions params and applies a different transformation to each subset.
+
+  Sometimes you may want to apply different transformations to different
+  parameters. For example, you may want to apply Adam to the weights of a
+  neural network, but SGD to the biases. This function allows you to do that.
+
+  Examples:
+
+    Below is an example where we apply Adam to the weights and SGD to the biases
+    of a 2-layer neural network::
+
+      >>> import optax
+      >>> import jax
+      >>> import jax.numpy as jnp
+
+      >>> def map_nested_fn(fn):
+      ...   '''Recursively apply `fn` to key-value pairs of a nested dict.'''
+      ...   def map_fn(nested_dict):
+      ...     return {k: (map_fn(v) if isinstance(v, dict) else fn(k, v))
+      ...             for k, v in nested_dict.items()}
+      ...   return map_fn
+
+      >>> params = {'linear_1': {'w': jnp.zeros((5, 6)), 'b': jnp.zeros(5)},
+      ...           'linear_2': {'w': jnp.zeros((6, 1)), 'b': jnp.zeros(1)}}
+      >>> gradients = jtu.tree_map(jnp.ones_like, params)  # dummy gradients
+
+      >>> label_fn = map_nested_fn(lambda k, _: k)
+      >>> tx = optax.multi_transform(
+      ...     {'w': optax.adam(1.0), 'b': optax.sgd(1.0)}, label_fn)
+      >>> state = tx.init(params)
+      >>> updates, new_state = tx.update(gradients, state, params)
+      >>> new_params = optax.apply_updates(params, updates)
+
+    Instead of providing a ``label_fn``, you may provide a PyTree of labels
+    directly.  Also, this PyTree may be a prefix of the parameters PyTree. This
+    is demonstrated in the GAN pseudocode below::
+
+      >>> generator_params = ...
+      >>> discriminator_params = ...
+      >>> all_params = (generator_params, discriminator_params)
+      >>> param_labels = ('generator', 'discriminator')
+
+      >>> tx = optax.multi_transform(
+      >>>     {'generator': optax.adam(0.1), 'discriminator': optax.adam(0.5)},
+      >>>     param_labels)
+
+    If you would like to not optimize some parameters, you may wrap
+    :func:`optax.multi_transform` with :func:`optax.masked`.
+
+  Args:
+    transforms: A mapping from labels to transformations. Each transformation
+      will be only be applied to parameters with the same label.
+    param_labels: A PyTree that is the same shape or a prefix of the
+      parameters/updates (or a function that returns one given the parameters as
+      input). The leaves of this PyTree correspond to the keys of the transforms
+      (therefore the values at the leaves must be a subset of the keys).
+    mask_compatible_extra_args: Whether to also apply the same masking to
+      extra_arg fields with the same tree structure as params/updates.
+
+  Returns:
+    A :func:`optax.GradientTransformationExtraArgs` that implements an ``init``
+    and ``update`` function.
+  """
+
+  transforms = {
+      k: base.with_extra_args_support(v)
+      for k, v in transforms.items()
+  }
+
+  def make_mask(labels, group):
+    return jax.tree_util.tree_map(lambda label: label == group, labels)
+
+  def init_fn(params):
+    labels = param_labels(params) if callable(param_labels) else param_labels
+
+    label_set = set(jax.tree_util.tree_leaves(labels))
+    if not label_set.issubset(transforms.keys()):
+      raise ValueError('Some parameters have no corresponding transformation.\n'
+                       f'Parameter labels: {list(sorted(label_set))} \n'
+                       f'Transforms keys: {list(sorted(transforms.keys()))} \n')
+
+    inner_states = {
+        group: wrappers.masked(
+            tx, make_mask(labels, group),
+            mask_compatible_extra_args=mask_compatible_extra_args).init(params)
+        for group, tx in transforms.items()
+    }
+    return PartitionState(inner_states)
+
+  def update_fn(updates, state, params=None, **extra_args):
+    labels = param_labels(updates) if callable(param_labels) else param_labels
+    new_inner_state = {}
+    for group, tx in transforms.items():
+      masked_tx = wrappers.masked(
+          tx, make_mask(labels, group),
+          mask_compatible_extra_args=mask_compatible_extra_args)
+      updates, new_inner_state[group] = masked_tx.update(
+          updates, state.inner_states[group], params, **extra_args)
+    return updates, PartitionState(new_inner_state)
+
+  return base.GradientTransformationExtraArgs(init_fn, update_fn)

testbed/google-deepmind__optax/optax/transforms/_combining_test.py

@@ -0,0 +1,284 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for `optax.transforms._combining.py`."""
+
+from absl.testing import absltest
+from absl.testing import parameterized
+
+import chex
+import jax
+import jax.numpy as jnp
+
+from optax._src import alias
+from optax._src import base
+from optax._src import transform
+from optax._src import update
+from optax.transforms import _accumulation
+from optax.transforms import _combining
+
+STEPS = 50
+LR = 1e-2
+
+
+class CombiningTest(chex.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    self.init_params = (jnp.array([1., 2.]), jnp.array([3., 4.]))
+    self.per_step_updates = (jnp.array([500., 5.]), jnp.array([300., 3.]))
+
+  @chex.all_variants
+  def test_chain(self):
+    transformations = [
+        transform.scale_by_adam(),
+        _accumulation.trace(decay=0, nesterov=False),
+        transform.scale(-LR)]
+
+    # Apply updates with chain.
+    chain_params = self.init_params
+    chained_transforms = _combining.chain(*transformations)
+    state = chained_transforms.init(chain_params)
+    self.assertIsInstance(state, tuple)
+
+    @self.variant
+    def update_fn(updates, state):
+      return chained_transforms.update(updates, state)
+
+    for _ in range(STEPS):
+      updates, state = update_fn(self.per_step_updates, state)
+      self.assertIsInstance(state, tuple)
+      chain_params = update.apply_updates(chain_params, updates)
+
+    # Manually apply sequence of transformations.
+    manual_params = self.init_params
+    states = [t.init(manual_params) for t in transformations]
+    for _ in range(STEPS):
+      updates = self.per_step_updates
+      new_states = []
+      for t, s in zip(transformations, states):
+        updates, state = t.update(updates, s)
+        new_states.append(state)
+      manual_params = update.apply_updates(manual_params, updates)
+      states = new_states
+
+    # Check equivalence.
+    chex.assert_trees_all_close(manual_params, chain_params, rtol=1e-4)
+
+
+def _map_keys_fn(fn):
+  def map_fn(nested_dict):
+    return {k: (map_fn(v) if isinstance(v, dict) else fn(k, v))
+            for k, v in nested_dict.items()}
+  return map_fn
+
+
+class ExtraArgsTest(chex.TestCase):
+
+  def test_extra_args(self):
+    def init_fn(params):
+      del params
+      return tuple()
+
+    # Arguments required by a transformation should be keyword-only.
+    # For example, the loss argument in this transformation.
+    def update_fn(updates, state, params=None, *, loss, **extra_args):
+      # Extra args should always be accepted.
+      del extra_args, params
+      assert loss == 1
+      return updates, state
+
+    t = base.GradientTransformationExtraArgs(init_fn, update_fn)
+    result = _combining.chain(alias.adam(1e-3), t)
+    self.assertIsInstance(result, base.GradientTransformationExtraArgs)
+
+    params = {'a': 1, 'b': 2}
+    state = result.init(params)
+    result.update(params, state, loss=1, ignored_kwarg='hi')
+
+  def test_extra_args_chaining(self):
+    def init_fn(params):
+      del params
+      return {}
+    def update_fn(updates, state, params=None):
+      del params
+      return updates, state
+
+    # Possible gotcha: Chaining regular gradient transformations results in
+    # a transformation that supports extra args.
+    t1 = base.GradientTransformation(init_fn, update_fn)
+    t2 = _combining.chain(t1, t1)
+    self.assertIsInstance(t2, base.GradientTransformation)
+    self.assertIsInstance(t2, base.GradientTransformationExtraArgs)
+
+    t3 = base.with_extra_args_support(t2)
+    self.assertIsInstance(t3, base.GradientTransformationExtraArgs)
+
+  def test_extra_args_positional_params(self):
+    def init_fn(params):
+      del params
+      return tuple()
+
+    def update_fn(updates, state, params=None):
+      assert params is not None
+      return updates, state
+
+    def update_fn_kwargs(updates, state, params=None, **extra_args):
+      del extra_args
+      assert params is not None
+      return updates, state
+
+    t1 = base.GradientTransformation(init_fn, update_fn)
+    t2 = base.GradientTransformationExtraArgs(init_fn, update_fn_kwargs)
+    opt = _combining.chain(t1, t2)
+    params = {'a': 1, 'b': 2}
+    state = opt.init(params)
+    opt.update(params, state, params, ignored_kwarg='hi')
+    opt.update(params, state, params=params, ignored_kwarg='hi')
+
+
+class PartitionTest(chex.TestCase):
+  """Tests for the partition wrapper."""
+
+  @chex.all_variants
+  @parameterized.parameters(True, False)
+  def test_partition(self, use_fn):
+    params = {'a1': 1., 'b1': 2., 'z1': {'a2': 3., 'z2': {'c1': 4.}}}
+    params = jax.tree_util.tree_map(jnp.asarray, params)
+    input_updates = jax.tree_util.tree_map(lambda x: x / 10.0, params)
+    tx_dict = {'a': transform.scale(-1.0),
+               'b': transform.ema(0.0),  # stateful
+               'c': transform.scale(2.0)}
+    param_labels = _map_keys_fn(lambda k, _: k[0])
+    if not use_fn:
+      param_labels = param_labels(params)
+    tx = _combining.partition(tx_dict, param_labels)
+    update_fn = self.variant(tx.update)
+    state = self.variant(tx.init)(params)
+
+    correct_update_fn = _map_keys_fn(
+        lambda k, v: {'a': -v, 'b': v, 'c': 2.0*v}[k[0]])
+
+    updates, state = update_fn(input_updates, state, params)
+    correct_updates = correct_update_fn(input_updates)
+    chex.assert_trees_all_close(updates, correct_updates)
+
+    # Check repeated application, this time with no params.
+    correct_updates = correct_update_fn(correct_updates)
+    updates, _ = update_fn(updates, state)
+    chex.assert_trees_all_close(updates, correct_updates)
+
+  def test_extra_args(self):
+
+    class ArgNotEqual1Error(ValueError):
+      """Raised when argument not set as expected."""
+
+    def init(params):
+      return {'mu': params}
+
+    def update_with_arg(updates, state, params=None, *, arg, **extra_args):
+      del params, extra_args
+      if arg != 1:
+        raise ArgNotEqual1Error()
+      return updates, state
+
+    def update_without_arg(updates, state, params=None):
+      del params
+      return updates, state
+
+    opt_no_arg = base.GradientTransformation(init, update_without_arg)
+    opt_extra_arg = base.GradientTransformationExtraArgs(init, update_with_arg)
+
+    opt = _combining.partition(
+        {
+            'a': opt_no_arg,
+            'b': opt_extra_arg,
+        },
+        ('a', 'b'),
+    )
+
+    fake_params = ({'u': jnp.array([1])}, {'v': jnp.array([1])})
+    state = opt.init(fake_params)
+
+    with self.assertRaises(TypeError):
+      opt.update(fake_params, state)
+    with self.assertRaises(ArgNotEqual1Error):
+      opt.update(fake_params, state, arg=2, ignored_kwarg='hi')
+    opt.update(fake_params, state, arg=1, ignored_kwarg='hi')
+
+  @parameterized.parameters(list, tuple, dict)
+  def test_empty(self, container):
+    init_fn, update_fn = _combining.partition(
+        {0: alias.sgd(1.)}, lambda _: 0)
+    updates, _ = update_fn(container(), init_fn(container()))
+    self.assertEqual(updates, container())
+
+  @chex.all_variants
+  @parameterized.parameters(
+      (False, False), (False, True), (True, False), (True, True))
+  def test_labels_mismatch(self, use_extra_label, use_fn):
+    # The labels from label_fn must be a subet of the keys for the tx.
+    params = {'a': 1., 'b': [2., 3.], 'c': {'d': 4., 'e': (5., 6.)}}
+    params = jax.tree_util.tree_map(jnp.asarray, params)
+    label_tree = {'a': 0, 'b': [1, 0], 'c': 1}  # prefix of params
+
+    if use_extra_label:
+      label_tree['a'] = 3
+
+    transforms = {0: alias.sgd(1.),
+                  1: alias.adam(1., b1=0., b2=0.),
+                  2: _accumulation.trace(1.0)}
+    init_fn, update_fn = _combining.partition(
+        transforms, (lambda _: label_tree) if use_fn else label_tree)
+
+    if use_extra_label:
+      with self.assertRaises(ValueError):
+        self.variant(init_fn)(params)
+    else:
+      state = self.variant(init_fn)(params)
+      updates = jax.tree_util.tree_map(lambda x: x / 10.0, params)
+      self.variant(update_fn)(updates, state)
+
+
+def scale_by_loss():
+  """Scale the gradient by the absolute value of the loss."""
+
+  def update_fn(updates, state, params, *, loss, **extra_args):
+    del params, extra_args
+    updates = jax.tree_util.tree_map(
+        lambda u: u / loss, updates)
+    return updates, state
+
+  return base.GradientTransformationExtraArgs(base.init_empty_state, update_fn)
+
+
+class NamedChainTest(absltest.TestCase):
+
+  def test_named_chain(self):
+    tx = _combining.named_chain(
+        ('scale', transform.scale(0.1)),
+        ('scale_loss', scale_by_loss()),
+    )
+
+    params = {'a': jnp.ones((4,))}
+    grads = params
+
+    opt_state = tx.init(params)
+    updates, _ = tx.update(grads, opt_state, params, loss=0.1)
+
+    chex.assert_trees_all_close(updates, {'a': jnp.ones((4,))})
+
+
+if __name__ == '__main__':
+  absltest.main()

testbed/google-deepmind__optax/optax/transforms/_conditionality.py

@@ -0,0 +1,253 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Wrappers that allow transformations to be applied conditionally."""
+
+from typing import Any, NamedTuple, Protocol
+
+import chex
+from jax import lax
+from jax import tree_util as jtu
+import jax.numpy as jnp
+
+from optax import tree_utils as otu
+from optax._src import base
+from optax._src import numerics
+
+
+class ConditionFn(Protocol):
+  """Condition function for conditional transformations."""
+
+  def __call__(
+      self,
+      step: chex.Array,
+      **extra_args: Any,
+  ) -> chex.Array:
+    """Update function with optional extra arguments.
+
+    Args:
+      step: a counter (array of shape [] and dtype ``int32``)
+      **extra_args: Additional keyword arguments passed to this condition fn.
+
+    Returns:
+      a boolean array of shape [] and dtype ``bool`` indicating whether the
+      inner transformation should be called.
+    """
+
+
+class ConditionallyTransformState(NamedTuple):
+  """Maintains inner transform state and adds a step counter."""
+  inner_state: Any
+  step: chex.Array
+
+
+def conditionally_transform(
+    inner: base.GradientTransformation,
+    should_transform_fn: ConditionFn,
+    forward_extra_args: bool = False,
+) -> base.GradientTransformationExtraArgs:
+  """Calls the inner update function only at certain steps.
+
+  Creates a transformation wrapper that conditionally applies the inner gradient
+  transformation, and if the condition is not met, just passes the updates and
+  inner state through unchanged. The behaviour is controlled by a user specified
+  function ``should_transform_fn`` that is called by ``conditionally_transform``
+  passing as input a counter of the number of times that the ``update`` function
+  has been previously called, the user specified function must returns a boolean
+  controlling whether the inner transformation should be called.
+
+  WARNING: if instead you want to set the ``updates`` to zero when the condition
+  is not met, you can use the ``conditionally_mask`` wrapper.
+
+  Args:
+    inner: the inner transformation.
+    should_transform_fn: function takes in a ``step`` counter (array of shape []
+      and dtype ``int32``), and returns a boolean array of shape []. If
+      ``forward_extra_args`` is set to True, any extra arguments are also
+      forwarded to the ``should_transform_fn``.
+    forward_extra_args: forward extra args to ``should_transform_fn``.
+
+  Returns:
+    A new ``GradientTransformationExtraArgs``.
+
+  .. versionadded:: 0.2.3
+  """
+  inner = base.with_extra_args_support(inner)
+
+  def init_fn(params):
+    return ConditionallyTransformState(
+        inner_state=inner.init(params), step=jnp.zeros([], dtype=jnp.int32))
+
+  def update_fn(updates, state, params=None, **extra_args):
+
+    def do_update(_):
+      return inner.update(updates, state.inner_state, params, **extra_args)
+
+    def reject_update(_):
+      return updates, state.inner_state
+
+    condition_kwargs = extra_args if forward_extra_args else {}
+    updates, new_inner_state = lax.cond(
+        should_transform_fn(state.step, **condition_kwargs),
+        do_update, reject_update, operand=None)
+    return updates, ConditionallyTransformState(
+        new_inner_state, numerics.safe_int32_increment(state.step))
+
+  return base.GradientTransformationExtraArgs(init_fn, update_fn)
+
+
+class ConditionallyMaskState(NamedTuple):
+  step: chex.Array
+  inner_state: base.OptState
+
+
+def conditionally_mask(
+    inner: base.GradientTransformation,
+    should_transform_fn: ConditionFn,
+    forward_extra_args: bool = False,
+) -> base.GradientTransformationExtraArgs:
+  """Calls the inner update function only at certain steps.
+
+  Creates a transformation wrapper that conditionally applies the inner gradient
+  transformation, and if the condition is not met, the updates are set to 0,
+  while the inner state is passed through unchanged. The behaviour is controlled
+  by a user specified function ``should_transform_fn`` that is called
+  by ``conditionally_transform`` passing as input a counter of the number of
+  times that the ``update`` function has been previously called, the user
+  specified function must returns a boolean controlling whether the inner
+  transformation should be called.
+
+  WARNING: if instead you want to leave ``updates`` unchanged when the condition
+  is not met, you can use the ``conditionally_transform`` wrapper.
+
+  Args:
+    inner: the inner transformation.
+    should_transform_fn: function takes in a step counter (array of shape []
+      and dtype ``int32``), and returns a boolean array of shape []. If
+      ``forward_extra_args`` is set to True, any extra arguments are also
+      forwarded to the ``should_transform_fn``.
+    forward_extra_args: forward extra args to ``should_transform_fn``.
+
+  Returns:
+    A new ``GradientTransformationExtraArgs``.
+
+  .. versionadded:: 0.2.3
+  """
+  inner = base.with_extra_args_support(inner)
+
+  def init_fn(params):
+    return ConditionallyMaskState(
+        step=jnp.zeros([], jnp.int32), inner_state=inner.init(params)
+    )
+
+  def update_fn(updates, state, params=None, **extra_args):
+
+    def do_update(_):
+      return inner.update(updates, state.inner_state, params, **extra_args)
+
+    def reject_update(_):
+      return otu.tree_zeros_like(updates), state.inner_state
+
+    condition_kwargs = extra_args if forward_extra_args else {}
+    updates, new_inner_state = lax.cond(
+        should_transform_fn(state.step, **condition_kwargs),
+        do_update, reject_update, operand=None)
+
+    return updates, ConditionallyMaskState(
+        step=numerics.safe_int32_increment(state.step),
+        inner_state=new_inner_state,
+    )
+
+  return base.GradientTransformationExtraArgs(init_fn, update_fn)
+
+
+class ApplyIfFiniteState(NamedTuple):
+  """State of the `GradientTransformation` returned by `apply_if_finite`.
+
+  Attributes:
+    notfinite_count: Number of consecutive gradient updates containing an Inf or
+      a NaN. This number is reset to 0 whenever a gradient update without an Inf
+      or a NaN is done.
+    last_finite: Whether or not the last gradient update contained an Inf or a
+      NaN.
+    total_notfinite: Total number of gradient updates containing an Inf or
+      a NaN since this optimizer was initialised. This number is never reset.
+      inner_state: The state of the inner `GradientTransformation`.
+
+  """
+  notfinite_count: Any
+  last_finite: Any
+  total_notfinite: Any
+  inner_state: Any
+
+
+def apply_if_finite(
+    inner: base.GradientTransformation,
+    max_consecutive_errors: int
+) -> base.GradientTransformation:
+  """A function that wraps an optimizer to make it robust to a few NaNs or Infs.
+
+  The purpose of this function is to prevent any optimization to happen if the
+  gradients contain NaNs or Infs. That is, when a NaN or Inf is detected in the
+  gradients, the wrapped optimizer ignores that gradient update. If the NaNs or
+  Infs persist after a given number of updates, the wrapped optimizer gives up
+  and accepts the update.
+
+  Args:
+    inner: Inner transformation to be wrapped.
+    max_consecutive_errors: Maximum number of consecutive gradient updates
+      containing NaNs or Infs that the wrapped optimizer will ignore. After
+      that many ignored updates, the optimizer will give up and accept.
+
+  Returns:
+    New ``GradientTransformationExtraArgs``.
+  """
+
+  inner = base.with_extra_args_support(inner)
+
+  def init(params):
+    return ApplyIfFiniteState(
+        notfinite_count=jnp.zeros([], jnp.int32),
+        last_finite=jnp.array(True, jnp.bool_),
+        total_notfinite=jnp.zeros([], jnp.int32),
+        inner_state=inner.init(params))
+
+  def update(updates, state, params=None, **extra_args):
+    inner_state = state.inner_state
+    flat_updates = jtu.tree_flatten(updates)[0]
+    isfinite = jnp.all(
+        jnp.array([jnp.all(jnp.isfinite(p)) for p in flat_updates]))
+    notfinite_count = jnp.where(
+        isfinite, jnp.zeros([], jnp.int32),
+        numerics.safe_int32_increment(state.notfinite_count))
+
+    def do_update(_):
+      return inner.update(updates, inner_state, params, **extra_args)
+
+    def reject_update(_):
+      return otu.tree_zeros_like(updates), inner_state
+
+    updates, new_inner_state = lax.cond(
+        jnp.logical_or(isfinite, notfinite_count > max_consecutive_errors),
+        do_update, reject_update, operand=None)
+
+    return updates, ApplyIfFiniteState(
+        notfinite_count=notfinite_count,
+        last_finite=isfinite,
+        total_notfinite=jnp.where(
+            isfinite, state.total_notfinite,
+            numerics.safe_int32_increment(state.total_notfinite)),
+        inner_state=new_inner_state)
+
+  return base.GradientTransformationExtraArgs(init=init, update=update)

testbed/google-deepmind__optax/optax/transforms/_conditionality_test.py

@@ -0,0 +1,286 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for optax.transforms._conditionality."""
+
+from absl.testing import absltest
+from absl.testing import parameterized
+
+import chex
+import jax
+import jax.numpy as jnp
+
+from optax._src import alias
+from optax._src import base
+from optax._src import combine
+from optax._src import transform
+from optax._src import update
+from optax.transforms import _conditionality
+from optax.transforms import _constraining
+
+
+def _build_sgd():
+  return alias.sgd(1.)
+
+
+def _build_stateful_sgd():
+  # This SGD behaves like _build_sgd but also tests the optimizer state. The
+  # momentum is set to zero rather than None so that the momentum terms are
+  # calculated, but do not change the results.
+  return alias.sgd(1., momentum=0.)
+
+
+def _build_sgd_extra_args():
+
+  def init_fn(params):
+    del params
+    return {'foo': 1}
+
+  def update_fn(grads, state, params=None, *, foo=None, **extra_args):
+    del extra_args, foo, params
+    return grads, state
+
+  t = base.GradientTransformationExtraArgs(init_fn, update_fn)
+  return combine.chain(_build_sgd(), t)
+
+
+class ConditionalityTest(parameterized.TestCase):
+
+  @chex.variants(with_jit=True, without_jit=True, with_pmap=True)
+  @parameterized.named_parameters(
+      ('sgd', _build_sgd),
+      ('stateful_sgd', _build_stateful_sgd),
+      ('sgd_extra_args', _build_sgd_extra_args),
+  )
+  def test_apply_if_finite(self, opt_builder):
+    one = jnp.array(1.)
+    nan = jnp.array(jnp.nan)
+
+    def fn(p, x):
+      return p * x
+
+    params = jnp.array(0.)
+    opt = _conditionality.apply_if_finite(opt_builder(), 2)
+    state = opt.init(params)
+    grads_fn = jax.grad(self.variant(fn))
+    # Do one successful param update
+    grads = grads_fn(params, one)
+    updates, state = opt.update(grads, state, params)
+    params = update.apply_updates(params, updates)
+    # We know exactly what should be the value of params since we are
+    # effectively using sgd in all cases.
+    self.assertEqual(-1., float(jax.tree_util.tree_flatten(params)[0][0]))
+    self.assertTrue(bool(getattr(state, 'last_finite')))
+    # Check 2 rejected param updates
+    for step in range(2):
+      grads = grads_fn(params, nan)
+      updates, state = opt.update(grads, state, params)
+      params = update.apply_updates(params, updates)
+      self.assertEqual(-1., float(jax.tree_util.tree_flatten(params)[0][0]))
+      self.assertFalse(bool(getattr(state, 'last_finite')))
+      self.assertEqual(step + 1, int(getattr(state, 'notfinite_count')))
+    # Next successful param update
+    grads = grads_fn(params, one)
+    updates, state = opt.update(grads, state, params)
+    params = update.apply_updates(params, updates)
+    self.assertEqual(-2., float(jax.tree_util.tree_flatten(params)[0][0]))
+    self.assertTrue(bool(getattr(state, 'last_finite')))
+    # Again 2 rejected param updates
+    for step in range(2):
+      grads = grads_fn(params, nan)
+      updates, state = opt.update(grads, state, params)
+      params = update.apply_updates(params, updates)
+      self.assertEqual(-2., float(jax.tree_util.tree_flatten(params)[0][0]))
+      self.assertFalse(bool(getattr(state, 'last_finite')))
+      self.assertEqual(step + 1, int(getattr(state, 'notfinite_count')))
+    # Next param update with NaN is accepted since we reached maximum
+    grads = grads_fn(params, nan)
+    updates, state = opt.update(grads, state, params)
+    params = update.apply_updates(params, updates)
+    self.assertTrue(bool(jnp.isnan(jax.tree_util.tree_flatten(params)[0][0])))
+    self.assertEqual(5, int(getattr(state, 'total_notfinite')))
+
+  def test_apply_if_finite_pmap(self):
+    # Unlike in `test_apply_if_finite`:
+    # * pmap is applied to the gradient computation and the optimisation;
+    # * the NaNs are caused inside the function and do not come from the inputs.
+    half = jnp.ones([1]) / 2.
+    two = jnp.ones([1]) * 2.  # Causes a NaN in arctanh
+    def fn(p, x):
+      return jnp.arctanh(x) * p
+
+    opt = _conditionality.apply_if_finite(alias.sgd(1.), 2)
+    def fn_update(params, opt_state, x):
+      grads = jax.grad(fn)(params, x)
+      grads = jax.lax.psum(grads, axis_name='i')
+      updates, new_opt_state = opt.update(grads, opt_state, params)
+      new_params = update.apply_updates(params, updates)
+      return new_params, new_opt_state
+    fn_update = jax.pmap(fn_update, axis_name='i')
+
+    params = jnp.array(0.)
+    opt_state = opt.init(params)
+    params = jax.tree_util.tree_map(lambda x: x[None], params)
+    opt_state = jax.tree_util.tree_map(lambda x: x[None], opt_state)
+    # Do one successful param update
+    params, opt_state = fn_update(params, opt_state, half)
+    self.assertTrue(bool(opt_state.last_finite))
+    # Check 2 rejected param updates
+    for step in range(2):
+      params, opt_state = fn_update(params, opt_state, two)
+      self.assertFalse(bool(opt_state.last_finite))
+      self.assertEqual(step + 1, opt_state.notfinite_count.item())
+    # Next successful param update
+    params, opt_state = fn_update(params, opt_state, half)
+    self.assertTrue(bool(opt_state.last_finite))
+    # Again 2 rejected param updates
+    for step in range(2):
+      params, opt_state = fn_update(params, opt_state, two)
+      self.assertFalse(bool(opt_state.last_finite))
+      self.assertEqual(step + 1, opt_state.notfinite_count.item())
+    # Next param update with NaN is accepted since we reached maximum
+    _, opt_state = fn_update(params, opt_state, two)
+    self.assertEqual(5, opt_state.total_notfinite.item())
+
+
+class ConditionallyTransformTest(chex.TestCase):
+  """Tests for the conditionally_transform wrapper."""
+
+  NUM_STEPS = 3
+
+  @chex.all_variants
+  def test_stateless_inner(self):
+    params = jnp.zeros([])
+    grads = jnp.ones([])
+
+    def should_update(step):
+      return step < ConditionallyTransformTest.NUM_STEPS
+
+    opt = _conditionality.conditionally_transform(
+        transform.scale(2.), should_update)
+    state = opt.init(params)
+    update_fn = self.variant(opt.update)
+    for _ in range(ConditionallyTransformTest.NUM_STEPS):
+      updates, state = update_fn(grads, state)
+      self.assertEqual(updates, 2.)
+    # Further updates stop calling the inner optimiser.
+    for _ in range(5):
+      updates, state = update_fn(grads, state)
+      self.assertEqual(updates, 1.)
+
+  @chex.all_variants
+  def test_statefull_inner(self):
+    params = jnp.zeros([])
+    grads_with_nan = jnp.array(float('nan'))
+    grads = jnp.ones([])
+
+    def should_update(step):
+      return step < ConditionallyTransformTest.NUM_STEPS
+
+    opt = _conditionality.conditionally_transform(
+        _constraining.zero_nans(), should_update)
+    state = opt.init(params)
+    update_fn = self.variant(opt.update)
+    for _ in range(ConditionallyTransformTest.NUM_STEPS - 1):
+      updates, state = update_fn(grads_with_nan, state)
+      self.assertEqual(updates, 0.)
+      self.assertEqual(state.inner_state.found_nan, True)
+    updates, state = update_fn(grads, state)
+    self.assertEqual(updates, 1.)
+    self.assertEqual(state.inner_state.found_nan, False)
+    # Further updates stop calling the inner optimiser.
+    for _ in range(5):
+      updates, state = update_fn(grads_with_nan, state)
+      # Warning: do not use assertEqual with a NaN as NaN == NaN returns False.
+      self.assertTrue(jnp.isnan(updates))
+      # Inner state is not be updated.
+      self.assertEqual(state.inner_state.found_nan, False)
+
+
+class ConditionallyMaskTest(chex.TestCase):
+  """Tests for the conditionally_mask wrapper."""
+
+  NUM_STEPS = 3
+  MIN_LOSS = 0.1
+
+  @chex.all_variants
+  def test_stateless_inner(self):
+    params = jnp.zeros([])
+    grads = jnp.ones([])
+
+    def should_update(step):
+      return step < ConditionallyMaskTest.NUM_STEPS
+
+    opt = _conditionality.conditionally_mask(transform.scale(2.), should_update)
+    state = opt.init(params)
+    update_fn = self.variant(opt.update)
+    for _ in range(ConditionallyMaskTest.NUM_STEPS):
+      updates, state = update_fn(grads, state)
+      self.assertEqual(updates, 2.)
+    # Further updates stop calling the inner optimiser.
+    for _ in range(5):
+      updates, state = update_fn(grads, state)
+      self.assertEqual(updates, 0.)
+
+  @chex.all_variants
+  def test_statefull_inner(self):
+    params = jnp.zeros([])
+    grads_with_nan = jnp.array(float('nan'))
+    grads = jnp.ones([])
+
+    def should_update(step):
+      return step < ConditionallyMaskTest.NUM_STEPS
+
+    opt = _conditionality.conditionally_mask(
+        _constraining.zero_nans(), should_update)
+    state = opt.init(params)
+    update_fn = self.variant(opt.update)
+    for _ in range(ConditionallyMaskTest.NUM_STEPS - 1):
+      updates, state = update_fn(grads_with_nan, state)
+      self.assertEqual(updates, 0.)
+      self.assertEqual(state.inner_state.found_nan, True)
+    updates, state = update_fn(grads, state)
+    self.assertEqual(updates, 1.)
+    self.assertEqual(state.inner_state.found_nan, False)
+    # Further updates stop calling the inner optimiser.
+    for _ in range(5):
+      updates, state = update_fn(grads_with_nan, state)
+      self.assertEqual(updates, 0.)
+      # Inner state is not be updated.
+      self.assertEqual(state.inner_state.found_nan, False)
+
+  @chex.all_variants
+  def test_stateless_inner_with_extra_args(self):
+    params = jnp.zeros([])
+    grads = jnp.ones([])
+
+    def should_update(step, loss, **extra_args):
+      del step, extra_args
+      return loss > ConditionallyMaskTest.MIN_LOSS
+
+    opt = _conditionality.conditionally_mask(
+        transform.scale(2.), should_update, forward_extra_args=True)
+    state = opt.init(params)
+    update_fn = self.variant(opt.update)
+    for _ in range(ConditionallyMaskTest.NUM_STEPS):
+      updates, state = update_fn(grads, state, loss=0.2)
+      self.assertEqual(updates, 2.)
+    # Further updates stop calling the inner optimiser.
+    for _ in range(5):
+      updates, state = update_fn(grads, state, loss=0.)
+      self.assertEqual(updates, 0.)
+
+
+if __name__ == '__main__':
+  absltest.main()

testbed/google-deepmind__optax/optax/transforms/_constraining.py

@@ -0,0 +1,93 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Gradient transformations used to enforce specific constraints."""
+
+from typing import Any, NamedTuple
+
+from jax import tree_util as jtu
+import jax.numpy as jnp
+
+from optax._src import base
+
+
+NonNegativeParamsState = base.EmptyState
+
+
+def keep_params_nonnegative() -> base.GradientTransformation:
+  """Modifies the updates to keep parameters non-negative, i.e. >= 0.
+
+  This transformation ensures that parameters after the update will be
+  larger than or equal to zero.
+  In a chain of transformations, this should be the last one.
+
+  WARNING: the transformation expects input params to be non-negative.
+  When params is negative the transformed update will move them to 0.
+
+  Returns:
+    A `GradientTransformation` object.
+  """
+
+  def init_fn(params):
+    del params
+    return NonNegativeParamsState()
+
+  def update_fn(updates, state, params):
+    if params is None:
+      raise ValueError(base.NO_PARAMS_MSG)
+
+    updates = jtu.tree_map(
+        lambda p, u: jnp.where((p + u) < 0., -p, u), params, updates)
+    return updates, state
+
+  return base.GradientTransformation(init_fn, update_fn)
+
+
+class ZeroNansState(NamedTuple):
+  """Contains a tree.
+
+  The entry `found_nan` has the same tree structure as that of the parameters.
+  Each leaf is a single boolean which contains True iff a NaN was detected in
+  the corresponding parameter array at the last call to `update`.
+  """
+  found_nan: Any
+
+
+def zero_nans() -> base.GradientTransformation:
+  """A transformation which replaces NaNs with 0.
+
+  The state of the transformation has the same tree structure as that of the
+  parameters. Each leaf is a single boolean which contains True iff a NaN was
+  detected in the corresponding parameter array at the last call to ``update``.
+  This state is not used by the transformation internally, but lets users be
+  aware when NaNs have been zeroed out.
+
+  Returns:
+    A `GradientTransformation`.
+  """
+
+  def init_fn(params):
+    return ZeroNansState(
+        found_nan=jtu.tree_map(
+            lambda p: jnp.array(False, dtype=jnp.bool_), params))
+
+  def update_fn(updates, opt_state, params=None):
+    del params, opt_state
+    opt_state = ZeroNansState(
+        found_nan=jtu.tree_map(lambda p: jnp.any(jnp.isnan(p)), updates))
+    updates = jtu.tree_map(
+        lambda p: jnp.where(jnp.isnan(p), jnp.zeros_like(p), p), updates)
+    return updates, opt_state
+
+  return base.GradientTransformation(init=init_fn, update=update_fn)

testbed/google-deepmind__optax/optax/transforms/_constraining_test.py

@@ -0,0 +1,119 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for optax.transforms._constraining."""
+
+from absl.testing import absltest
+import chex
+import jax.numpy as jnp
+
+from optax._src import combine
+from optax._src import transform
+from optax._src import update
+from optax.transforms import _accumulation
+from optax.transforms import _constraining
+
+
+STEPS = 50
+LR = 1e-2
+
+
+class ConstraintsTest(chex.TestCase):
+
+  def test_keep_params_nonnegative(self):
+    grads = (jnp.array([500., -500., 0.]),
+             jnp.array([500., -500., 0.]),
+             jnp.array([500., -500., 0.]))
+
+    params = (jnp.array([-1., -1., -1.]),
+              jnp.array([1., 1., 1.]),
+              jnp.array([0., 0., 0.]))
+
+    # vanilla sgd
+    opt = combine.chain(
+        _accumulation.trace(decay=0, nesterov=False),
+        transform.scale(-LR))
+    opt_state = opt.init(params)
+
+    updates, _ = opt.update(grads, opt_state, params)
+    new_params = update.apply_updates(params, updates)
+
+    chex.assert_trees_all_close(new_params, (jnp.array([-6., 4., -1.]),
+                                             jnp.array([-4., 6., 1.]),
+                                             jnp.array([-5., 5., 0.])))
+
+    # sgd with keeping parameters non-negative
+    opt = combine.chain(
+        _accumulation.trace(decay=0, nesterov=False),
+        transform.scale(-LR),
+        _constraining.keep_params_nonnegative())
+    opt_state = opt.init(params)
+
+    updates, _ = opt.update(grads, opt_state, params)
+    new_params = update.apply_updates(params, updates)
+
+    chex.assert_trees_all_close(new_params, (jnp.array([0., 4., 0.]),
+                                             jnp.array([0., 6., 1.]),
+                                             jnp.array([0., 5., 0.])))
+
+  @chex.all_variants
+  def test_zero_nans(self):
+    params = (jnp.zeros([3]), jnp.zeros([3]), jnp.zeros([3]))
+
+    opt = _constraining.zero_nans()
+    opt_state = self.variant(opt.init)(params)
+    update_fn = self.variant(opt.update)
+
+    chex.assert_trees_all_close(
+        opt_state,
+        _constraining.ZeroNansState((jnp.array(False),) * 3))
+
+    # Check an upate with nans
+    grads_with_nans = (jnp.ones([3]),
+                       jnp.array([1., float('nan'), float('nan')]),
+                       jnp.array([float('nan'), 1., 1.]))
+    updates, opt_state = update_fn(grads_with_nans, opt_state)
+    chex.assert_trees_all_close(
+        opt_state,
+        _constraining.ZeroNansState(
+            (jnp.array(False), jnp.array(True), jnp.array(True))))
+    chex.assert_trees_all_close(
+        updates,
+        (jnp.ones([3]), jnp.array([1., 0., 0.]), jnp.array([0., 1., 1.])))
+
+    # Check an upate with nans and infs
+    grads_with_nans_infs = (jnp.ones([3]),
+                            jnp.array([1., float('nan'),
+                                       float('nan')]),
+                            jnp.array([float('inf'), 1., 1.]))
+    updates, opt_state = update_fn(grads_with_nans_infs, opt_state)
+    chex.assert_trees_all_close(
+        opt_state,
+        _constraining.ZeroNansState(
+            (jnp.array(False), jnp.array(True), jnp.array(False))))
+    chex.assert_trees_all_close(updates, (jnp.ones([3]), jnp.array(
+        [1., 0., 0.]), jnp.array([float('inf'), 1., 1.])))
+
+    # Check an upate with only good values
+    grads = (jnp.ones([3]), jnp.ones([3]), jnp.ones([3]))
+    updates, opt_state = update_fn(grads, opt_state)
+    chex.assert_trees_all_close(
+        opt_state,
+        _constraining.ZeroNansState(
+            (jnp.array(False), jnp.array(False), jnp.array(False))))
+    chex.assert_trees_all_close(updates, grads)
+
+
+if __name__ == '__main__':
+  absltest.main()

testbed/google-deepmind__optax/optax/transforms/_layouts.py

@@ -0,0 +1,77 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Wrappers changing the layouts of the tensors that transforms operate on."""
+
+from jax import tree_util as jtu
+import jax.numpy as jnp
+import numpy as np
+
+from optax._src import base
+
+
+def flatten(
+    inner: base.GradientTransformation
+) -> base.GradientTransformationExtraArgs:
+  """Flattens parameters and gradients for init and update of inner transform.
+
+  This can reduce the overhead of performing many calculations on lots of small
+  variables, at the cost of slightly increased memory usage.
+
+  Args:
+    inner: Inner transformation to flatten inputs for.
+
+  Returns:
+    New ``GradientTransformationExtraArgs``
+  """
+
+  inner = base.with_extra_args_support(inner)
+
+  def _flatten(params):
+    """Flattens and concatenates all tensors in params to a single vector."""
+    params, _ = jtu.tree_flatten(params)
+    return jnp.concatenate([jnp.reshape(param, [-1]) for param in params])
+
+  def _unflatten(updates, flat):
+    """Extracts tensors from flat, using the structure and shapes of params."""
+    updates_flat, treedef = jtu.tree_flatten(updates)
+    offsets = []
+    for update in updates_flat:
+      size = np.size(update)
+      if offsets:
+        offsets.append(size + offsets[-1])
+      else:
+        offsets.append(size)
+    del offsets[-1]
+    flat_split = jnp.split(flat, offsets)
+    reshaped = [
+        jnp.reshape(flat_update, update.shape)
+        for flat_update, update in zip(flat_split, updates_flat)
+    ]
+    return jtu.tree_unflatten(treedef, reshaped)
+
+  def init_fn(params):
+    flat = _flatten(params)
+    return inner.init(flat)
+
+  def update_fn(updates, state, params=None, **extra_args):
+    if params is not None:
+      params = _flatten(params)
+    updates_flat, state = inner.update(
+        _flatten(updates), state, params, **extra_args
+    )
+    updates = _unflatten(updates, updates_flat)
+    return updates, state
+
+  return base.GradientTransformationExtraArgs(init_fn, update_fn)

testbed/google-deepmind__optax/optax/transforms/_layouts_test.py

@@ -0,0 +1,59 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for optax.transforms._layouts."""
+
+from absl.testing import absltest
+import chex
+import jax.numpy as jnp
+
+from optax._src import alias
+from optax._src import update
+from optax.transforms import _layouts
+
+
+class LayoutsTest(absltest.TestCase):
+
+  def test_flatten(self):
+    def init_params():
+      return (jnp.array(2.), jnp.array([1., 2.]), jnp.array([3., 4.]))
+
+    per_step_updates = (
+        jnp.array(1.0),
+        jnp.array([500.0, 5.0]),
+        jnp.array([300.0, 3.0]),
+    )
+
+    # First calculate new params without flattening
+    optax_sgd_params = init_params()
+    sgd = alias.sgd(1e-2, 0.0)
+    state_sgd = sgd.init(optax_sgd_params)
+    updates_sgd, _ = sgd.update(per_step_updates, state_sgd)
+    sgd_params_no_flatten = update.apply_updates(optax_sgd_params, updates_sgd)
+
+    # And now calculate new params with flattening
+    optax_sgd_params = init_params()
+    sgd = _layouts.flatten(sgd)
+
+    state_sgd = sgd.init(optax_sgd_params)
+    updates_sgd, _ = sgd.update(per_step_updates, state_sgd)
+    sgd_params_flatten = update.apply_updates(optax_sgd_params, updates_sgd)
+
+    # Test that both give the same result
+    chex.assert_trees_all_close(
+        sgd_params_no_flatten, sgd_params_flatten, atol=1e-7, rtol=1e-7)
+
+
+if __name__ == "__main__":
+  absltest.main()

testbed/google-deepmind__optax/optax/transforms/_masking.py

@@ -0,0 +1,136 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Wrappers that mask out part of the parameters when applying a transform."""
+
+from typing import Any, Callable, NamedTuple, Union
+
+from jax import tree_util as jtu
+
+from optax._src import base
+from optax.tree_utils import _state_utils
+
+
+class MaskedState(NamedTuple):
+  """Maintains inner transform state for masked transformations."""
+  inner_state: Any
+
+
+class MaskedNode(NamedTuple):
+  """A node used to mask out unspecified parts of a tree.
+
+  This node is ignored when mapping functions across the tree e.g. using
+  `jtu.tree_map` since it is a container without children. It can
+  therefore be used to mask out parts of a tree.
+  """
+
+
+def masked(
+    inner: base.GradientTransformation,
+    mask: Union[base.PyTree, Callable[[base.Params], base.PyTree]],
+    *,
+    mask_compatible_extra_args: bool = False,
+) -> base.GradientTransformationExtraArgs:
+  """Mask updates so only some are transformed, the rest are passed through.
+
+  For example, it is common to skip weight decay for BatchNorm scale and all
+  bias parameters. Since in many networks, these are the only 1D parameters,
+  you may for instance create a mask function to mask them out as follows::
+
+    mask_fn = lambda p: jtu.tree_map(lambda x: x.ndim != 1, p)
+    weight_decay = optax.masked(optax.add_decayed_weights(0.001), mask_fn)
+
+  You may alternatively create the mask pytree upfront::
+
+    mask = jtu.tree_map(lambda x: x.ndim != 1, params)
+    weight_decay = optax.masked(optax.add_decayed_weights(0.001), mask)
+
+  For the ``inner`` transform, state will only be stored for the parameters that
+  have a mask value of ``True``.
+
+  Note that, when using ``tree_map_params``, it may be required to pass the
+  argument `is_leaf=lambda v: isinstance(v, optax.MaskedNode)`, if the tree
+  map needs to take additional arguments with the same shape as the original
+  input tree.
+
+  Args:
+    inner: Inner transformation to mask.
+    mask: a PyTree with same structure as (or a prefix of) the params PyTree, or
+      a Callable that returns such a pytree given the params/updates. The leaves
+      should be booleans, ``True`` for leaves/subtrees you want to apply the
+      transformation to, and ``False`` for those you want to skip. The mask must
+      be static for the gradient transformation to be jit-compilable.
+    mask_compatible_extra_args: whether to also apply the same masking to
+      extra_arg fields with the same tree structure as params/updates.
+
+  Returns:
+    New ``GradientTransformationExtraArgs`` wrapping ``inner``.
+  """
+  inner = base.with_extra_args_support(inner)
+
+  def mask_pytree(pytree, mask_tree):
+    return jtu.tree_map(
+        lambda m, p: p if m else MaskedNode(), mask_tree, pytree
+    )
+
+  # It is possible that `extra_args` of update_fn has pytrees with the same
+  # structure as params/updates, e.g. parameter tags. This function applies
+  # the mask to those pytrees.
+  def maybe_mask_values(pytree_dict, base_pytree, mask_tree):
+    base_structure = jtu.tree_structure(base_pytree)
+
+    def _maybe_mask(pytree):
+      if mask_compatible_extra_args and (
+          jtu.tree_structure(pytree) == base_structure):
+        return mask_pytree(pytree, mask_tree)
+      else:
+        return pytree
+
+    return {k: _maybe_mask(v) for k, v in pytree_dict.items()}
+
+  def init_fn(params):
+    # This is a workaround to make tree_map_params work with masking.
+    # The API of `masked` takes a mask on construction, instead of at init.
+    # This means that this gradient transformation can only work for parameter
+    # trees that match the shape of the mask. Technically this breaks the API
+    # of optax, and this causes tree_map_params to break. This is because
+    # tree_map_params calls init with a placeholder in order to detect copies
+    # of the parameter tree. As a (slightly ugly) workaround, we detect when
+    # the init is being called by tree_map_params, and pass the placeholder
+    # down without masking. This is safe, since tree_map_params does not impose
+    # any particular constraints on the shape of the parameter tree, as long
+    # as tree_map_params is being called on a tree with the correct structure.
+    # See wrappers_test for proof that this works!
+    if isinstance(params, _state_utils._ParamsPlaceholder):  # pylint:disable=protected-access
+      return MaskedState(inner_state=inner.init(params))
+
+    mask_tree = mask(params) if callable(mask) else mask
+    masked_params = mask_pytree(params, mask_tree)
+    return MaskedState(inner_state=inner.init(masked_params))
+
+  def update_fn(updates, state, params=None, **extra_args):
+    mask_tree = mask(updates) if callable(mask) else mask
+    masked_extra_args = maybe_mask_values(extra_args, updates, mask_tree)
+    masked_updates = mask_pytree(updates, mask_tree)
+    masked_params = None if params is None else mask_pytree(params, mask_tree)
+
+    new_masked_updates, new_inner_state = inner.update(
+        masked_updates, state.inner_state, masked_params, **masked_extra_args)
+
+    new_updates = jtu.tree_map(
+        lambda m, new_u, old_u: new_u if m else old_u,
+        mask_tree, new_masked_updates, updates)
+    return new_updates, MaskedState(inner_state=new_inner_state)
+
+  return base.GradientTransformationExtraArgs(init_fn, update_fn)

testbed/google-deepmind__optax/optax/transforms/_masking_test.py

@@ -0,0 +1,348 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for optax.transforms._masking."""
+
+import copy
+from typing import cast
+
+from absl.testing import absltest
+from absl.testing import parameterized
+
+import chex
+from jax import tree_util as jtu
+import jax.numpy as jnp
+import numpy as np
+
+from optax._src import alias
+from optax._src import base
+from optax._src import combine
+from optax._src import transform
+from optax._src import update
+from optax.transforms import _masking
+from optax.tree_utils import _state_utils
+
+
+def _build_sgd():
+  return alias.sgd(1.)
+
+
+def _build_stateful_sgd():
+  # This SGD behaves like _build_sgd but also tests the optimizer state. The
+  # momentum is set to zero rather than None so that the momentum terms are
+  # calculated, but do not change the results.
+  return alias.sgd(1., momentum=0.)
+
+
+def _build_sgd_extra_args():
+
+  def init_fn(params):
+    del params
+    return {'foo': 1}
+
+  def update_fn(grads, state, params=None, *, foo=None, **extra_args):
+    del extra_args, foo, params
+    return grads, state
+
+  t = base.GradientTransformationExtraArgs(init_fn, update_fn)
+  return combine.chain(_build_sgd(), t)
+
+
+class MaskedTest(chex.TestCase):
+  """Tests for the masked wrapper."""
+
+  def test_tree_map_params(self):
+    params = {
+        'a': {
+            'b': (jnp.zeros((1, 2)), jnp.zeros((2, 2))),
+        },
+        'c': {
+            'd': jnp.zeros((1, 2)),
+            'e': (jnp.zeros((1, 2)), jnp.zeros((1, 2))),
+        },
+    }
+
+    sharding_axes = {
+        'a': {
+            'b': (1, 2),
+        },
+        'c': {
+            'd': 1,
+            'e': (1, 2),
+        },
+    }
+
+    mask = {
+        'a': {
+            'b': (True, False),
+        },
+        'c': {
+            'd': True,
+            'e': (False, True),
+        },
+    }
+
+    expected = {
+        'a': {
+            'b': (jnp.ones((1, 2)), jnp.zeros((2, 2))),
+        },
+        'c': {
+            'd': jnp.ones((1, 2)),
+            'e': (jnp.ones((1, 2)), jnp.ones((1, 2))),
+        },
+    }
+
+    def init_fn(params):
+      return {'count': 1, 'params': params, 'params_copy': params}
+
+    def update_fn(updates, state, params=None):
+      del params
+      return updates, state
+
+    inner = base.GradientTransformation(init_fn, update_fn)
+    masked = _masking.masked(inner, mask)
+
+    def increment_dim_1(v):
+      return v + 1 if v.shape[0] == 1 else v
+
+    # For this optimizer, tree_map_params should have the same effect on a
+    # masked optimizer state as it does on an unmasked optimizer state.
+    with self.subTest('inner'):
+      state = inner.init(params)
+      result = _state_utils.tree_map_params(inner, increment_dim_1, state)
+      chex.assert_trees_all_equal(result, inner.init(expected))
+
+    with self.subTest('masked'):
+      state = masked.init(params)
+      result = _state_utils.tree_map_params(masked, increment_dim_1, state)
+      chex.assert_trees_all_equal(result, masked.init(expected))
+
+    with self.subTest('masked_with_extra_args'):
+      # Users wishing to pass additional arguments with the same tree structure
+      # as the original params pytree will need to add the additional `is_leaf`
+      # callable. This makes it possible to ignore the masked parts of the
+      # pytree.
+
+      # Replace all non-masked parameters in the opt-state tree with the
+      # sharding axis values given in the tree above. Everything else is set to
+      # None.
+      new_state = _state_utils.tree_map_params(
+          masked,
+          lambda p, axis: None if isinstance(p, _masking.MaskedNode) else axis,
+          state,
+          sharding_axes,
+          is_leaf=lambda v: isinstance(v, _masking.MaskedNode),
+          transform_non_params=lambda v: None,
+      )
+
+      sharded_params = {
+          'a': {
+              'b': (1, None),
+          },
+          'c': {
+              'd': 1,
+              'e': (None, 2),
+          },
+      }
+
+      # Required to make pytype happy
+      new_state = cast(_masking.MaskedState, new_state)
+
+      chex.assert_equal(None, new_state.inner_state['count'])
+      chex.assert_equal(sharded_params, new_state.inner_state['params'])
+      chex.assert_equal(sharded_params, new_state.inner_state['params_copy'])
+
+  @chex.all_variants
+  @parameterized.named_parameters(
+      ('sgd', _build_sgd, False),
+      ('stateful_sgd', _build_stateful_sgd, False),
+      ('sgd_w_mask_fn', _build_sgd, True),
+      ('stateful_sgd_w_mask_fn', _build_stateful_sgd, True),
+  )
+  def test_masked(self, opt_builder, use_fn):
+    mask = {'a': True,
+            'b': [False, True],
+            'c': {'d': True, 'e': (False, True)}}
+    mask_arg = lambda _: mask if use_fn else mask
+    params = {'a': 1., 'b': [2., 3.], 'c': {'d': 4., 'e': (5., 6.)}}
+    params = jtu.tree_map(jnp.asarray, params)
+    input_updates = jtu.tree_map(lambda x: x/10., params)
+
+    # Negate the updates wherever the mask is True
+    def masked_negate(updates):
+      return jtu.tree_map(
+          lambda upd, m: -upd if m else upd, updates, mask)
+    correct_updates = masked_negate(input_updates)
+
+    init_fn, update_fn = _masking.masked(opt_builder(), mask_arg)
+    update_fn = self.variant(update_fn)
+    state = self.variant(init_fn)(params)
+
+    with self.subTest('tree_map_params'):
+      result = _state_utils.tree_map_params(init_fn, lambda v: v, state)
+      chex.assert_trees_all_equal_structs(result, state)
+
+    updates, state = update_fn(input_updates, state, params)
+    chex.assert_trees_all_close(updates, correct_updates)
+
+    # Check repeated application, this time with no params.
+    correct_updates = masked_negate(correct_updates)
+    updates, _ = update_fn(updates, state)
+    chex.assert_trees_all_close(updates, correct_updates)
+
+  @chex.all_variants
+  @parameterized.named_parameters(
+      ('sgd', _build_sgd),
+      ('stateful_sgd', _build_stateful_sgd),
+  )
+  def test_prefix_mask(self, opt_builder):
+    """Test when the mask is a prefix of the updates PyTree."""
+    mask = {'a': True, 'b': False, 'c': {'d': False, 'e': True}}
+    params = {'a': 1., 'b': {'f': 2.}, 'c': {'d': 3., 'e': ([4., 5.], 6.)}}
+    params = jtu.tree_map(jnp.asarray, params)
+    input_updates = jtu.tree_map(lambda x: x/10., params)
+
+    # Negate the updates wherever the mask (or mask parent) is True
+    def _masked_sgd_on_updates(m, upd):
+      return jtu.tree_map(lambda x: -x, upd) if m else upd
+    correct_updates = jtu.tree_map(
+        _masked_sgd_on_updates, mask, input_updates)
+
+    init_fn, update_fn = _masking.masked(opt_builder(), mask)
+    update_fn = self.variant(update_fn)
+    state = self.variant(init_fn)(params)
+    updates, state = update_fn(input_updates, state, params)
+    chex.assert_trees_all_close(updates, correct_updates)
+
+    # Check repeated application, this time with no params.
+    correct_updates = jtu.tree_map(
+        _masked_sgd_on_updates, mask, correct_updates)
+    updates, _ = update_fn(updates, state)
+    chex.assert_trees_all_close(updates, correct_updates)
+
+  @chex.all_variants
+  def test_update_requires_params(self):
+    weight_decay = 0.1
+    mask = {'a': True,
+            'b': [False, True],
+            'c': {'d': True, 'e': (False, True)}}
+    params = {'a': 1., 'b': [2., 3.], 'c': {'d': 4., 'e': (5., 6.)}}
+    params = jtu.tree_map(jnp.asarray, params)
+    input_updates = jtu.tree_map(lambda x: x/10., params)
+
+    correct_updates = jtu.tree_map(
+        lambda m, u, p: u + weight_decay * p if m else u,
+        mask, input_updates, params)
+
+    init_fn, update_fn = _masking.masked(
+        transform.add_decayed_weights(weight_decay), mask)
+    update_fn = self.variant(update_fn)
+
+    state = self.variant(init_fn)(params)
+    updates, state = update_fn(input_updates, state, params)
+    chex.assert_trees_all_close(updates, correct_updates)
+
+    params = update.apply_updates(params, updates)
+
+    # Test repeated application
+    new_correct_updates = jtu.tree_map(
+        lambda m, u, p: u + weight_decay * p if m else u,
+        mask, correct_updates, params)
+    updates, _ = update_fn(correct_updates, state, params)
+    chex.assert_trees_all_close(updates, new_correct_updates)
+
+  @parameterized.parameters(list, tuple, dict)
+  def test_empty(self, container):
+    init_fn, update_fn = _masking.masked(_build_sgd(), container())
+    update_fn(container(), init_fn(container()))
+
+  @parameterized.parameters(
+      (False, False), (False, True), (True, False), (True, True))
+  def test_tree_mismatch_fails(self, extra_key_in_mask, use_fn):
+    mask = {'a': True,
+            'b': [False, True],
+            'c': {'d': True, 'e': (False, True)}}
+    mask_arg = lambda _: mask if use_fn else mask
+    params = {'a': 1., 'b': [2., 3.], 'c': {'d': 4., 'e': (5., 6.)}}
+    params = jtu.tree_map(jnp.asarray, params)
+
+    if extra_key_in_mask:
+      mask['c']['extra'] = True
+    else:
+      params['c']['extra'] = 7
+
+    init_fn = _masking.masked(_build_sgd(), mask_arg)[0]
+    with self.assertRaises(ValueError):
+      init_fn(params)
+
+  @chex.all_variants
+  def test_mask_fn(self):
+    params = {'a': jnp.ones((1, 2)), 'b': (jnp.ones((1,)), np.ones((1, 2, 3)))}
+    mask_fn = lambda p: jtu.tree_map(lambda x: x.ndim > 1, p)
+    init_fn, update_fn = _masking.masked(
+        transform.add_decayed_weights(0.1), mask_fn)
+    update_fn = self.variant(update_fn)
+
+    state = self.variant(init_fn)(params)
+    grads = jtu.tree_map(lambda x: x*2, params)
+    updates, _ = update_fn(grads, state, params)
+    np.testing.assert_allclose(updates['a'], grads['a'] + 0.1*params['a'])
+    np.testing.assert_allclose(updates['b'][0], grads['b'][0])
+    np.testing.assert_allclose(updates['b'][1],
+                               grads['b'][1] + 0.1*params['b'][1])
+
+  @chex.all_variants
+  @parameterized.named_parameters(
+      ('sgd', _build_sgd),
+      ('stateful_sgd', _build_stateful_sgd),
+  )
+  def test_nested_mask(self, opt_builder):
+    # https://github.com/deepmind/optax/issues/271
+    params = {'linear_1': {'w': jnp.zeros((1, 1)), 'b': jnp.zeros(1)},
+              'linear_2': {'w': jnp.zeros((1, 2)), 'b': jnp.zeros(2)},
+              'linear_3': {'w': jnp.zeros((2, 3)), 'b': jnp.zeros(3)}}
+
+    outer_mask = lambda p: jtu.tree_map(lambda x: x.ndim > 1, p)
+    inner_mask = jtu.tree_map(lambda _: True, params)
+    inner_mask['linear_2'] = False
+
+    inner = _masking.masked(opt_builder(), inner_mask)
+    init_fn, update_fn = _masking.masked(inner, outer_mask)
+
+    input_updates = jtu.tree_map(jnp.ones_like, params)
+    correct_updates = copy.deepcopy(input_updates)
+    correct_updates['linear_1']['w'] *= -1.0
+    correct_updates['linear_3']['w'] *= -1.0
+
+    state = self.variant(init_fn)(params)
+    updates, _ = self.variant(update_fn)(input_updates, state, params)
+    chex.assert_trees_all_close(updates, correct_updates)
+
+  @chex.all_variants
+  def test_masked_state_structure(self):
+    # https://github.com/deepmind/optax/issues/271
+    params = {'a': [jnp.ones(1), (jnp.ones(2), jnp.ones(3))],
+              'b': {'c': jnp.ones(4), 'd': jnp.ones(5)}}
+    mask = {'a': [True, (True, False)], 'b': False}
+    tx = _masking.masked(_build_stateful_sgd(), mask)
+    trace = self.variant(tx.init)(params).inner_state[0].trace
+    expected_trace = {
+        'a': [jnp.zeros(1), (jnp.zeros(2), _masking.MaskedNode())],
+        'b': _masking.MaskedNode()
+    }
+    chex.assert_trees_all_equal_structs(trace, expected_trace)
+
+
+if __name__ == '__main__':
+  absltest.main()

testbed/google-deepmind__optax/optax/tree_utils/__init__.py

@@ -0,0 +1,41 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""The tree_utils sub-package."""
+
+from optax.tree_utils._casting import tree_cast
+from optax.tree_utils._random import tree_random_like
+from optax.tree_utils._state_utils import NamedTupleKey
+from optax.tree_utils._state_utils import tree_get
+from optax.tree_utils._state_utils import tree_get_all_with_path
+from optax.tree_utils._state_utils import tree_map_params
+from optax.tree_utils._state_utils import tree_set
+from optax.tree_utils._tree_math import tree_add
+from optax.tree_utils._tree_math import tree_add_scalar_mul
+from optax.tree_utils._tree_math import tree_bias_correction
+from optax.tree_utils._tree_math import tree_clip
+from optax.tree_utils._tree_math import tree_div
+from optax.tree_utils._tree_math import tree_full_like
+from optax.tree_utils._tree_math import tree_l1_norm
+from optax.tree_utils._tree_math import tree_l2_norm
+from optax.tree_utils._tree_math import tree_mul
+from optax.tree_utils._tree_math import tree_ones_like
+from optax.tree_utils._tree_math import tree_scalar_mul
+from optax.tree_utils._tree_math import tree_sub
+from optax.tree_utils._tree_math import tree_sum
+from optax.tree_utils._tree_math import tree_update_infinity_moment
+from optax.tree_utils._tree_math import tree_update_moment
+from optax.tree_utils._tree_math import tree_update_moment_per_elem_norm
+from optax.tree_utils._tree_math import tree_vdot
+from optax.tree_utils._tree_math import tree_zeros_like

testbed/google-deepmind__optax/optax/tree_utils/_casting.py

@@ -0,0 +1,31 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Utilities to cast pytrees to specific dtypes."""
+
+from typing import Optional
+
+import chex
+from jax import tree_util as jtu
+
+
+def tree_cast(
+    tree: chex.ArrayTree,
+    dtype: Optional[chex.ArrayDType]
+) -> chex.ArrayTree:
+  """Cast tree to given dtype, skip if None."""
+  if dtype is not None:
+    return jtu.tree_map(lambda t: t.astype(dtype), tree)
+  else:
+    return tree

testbed/google-deepmind__optax/optax/tree_utils/_casting_test.py

@@ -0,0 +1,50 @@
+# Copyright 2021 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for optax.tree_utils._casting."""
+
+from absl.testing import absltest
+from absl.testing import parameterized
+
+from jax import tree_util as jtu
+import jax.numpy as jnp
+import numpy as np
+
+from optax import tree_utils as otu
+
+
+class CastingTest(parameterized.TestCase):
+
+  @parameterized.parameters([
+      (jnp.float32, [1.3, 2.001, 3.6], [-3.3], [1.3, 2.001, 3.6], [-3.3]),
+      (jnp.float32, [1.3, 2.001, 3.6], [-3], [1.3, 2.001, 3.6], [-3.0]),
+      (jnp.int32, [1.3, 2.001, 3.6], [-3.3], [1, 2, 3], [-3]),
+      (jnp.int32, [1.3, 2.001, 3.6], [-3], [1, 2, 3], [-3]),
+      (None, [1.123, 2.33], [0.0], [1.123, 2.33], [0.0]),
+      (None, [1, 2, 3], [0.0], [1, 2, 3], [0.0]),
+  ])
+  def test_tree_cast(self, dtype, b, c, new_b, new_c):
+    def _build_tree(val1, val2):
+      dict_tree = {'a': {'b': jnp.array(val1)}, 'c': jnp.array(val2)}
+      return jtu.tree_map(lambda x: x, dict_tree)
+
+    tree = _build_tree(b, c)
+    tree = otu.tree_cast(tree, dtype=dtype)
+    jtu.tree_map(
+        np.testing.assert_array_equal, tree, _build_tree(new_b, new_c)
+    )
+
+
+if __name__ == '__main__':
+  absltest.main()

testbed/google-deepmind__optax/optax/tree_utils/_random.py

@@ -0,0 +1,68 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Utilities to generate random pytrees."""
+
+from typing import Callable
+
+import chex
+import jax
+from jax import tree_util as jtu
+
+from optax._src import base
+
+
+def _tree_rng_keys_split(
+    rng_key: chex.PRNGKey, target_tree: chex.ArrayTree
+) -> chex.ArrayTree:
+  """Split keys to match structure of target tree.
+
+  Args:
+    rng_key: the key to split.
+    target_tree: the tree whose structure to match.
+
+  Returns:
+    a tree of rng keys.
+  """
+  tree_def = jtu.tree_structure(target_tree)
+  keys = jax.random.split(rng_key, tree_def.num_leaves)
+  return jtu.tree_unflatten(tree_def, keys)
+
+
+def tree_random_like(
+    rng_key: chex.PRNGKey,
+    target_tree: chex.ArrayTree,
+    sampler: Callable[
+        [chex.PRNGKey, base.Shape], chex.Array
+    ] = jax.random.normal,
+) -> chex.ArrayTree:
+  """Create tree with random entries of the same shape as target tree.
+
+  Args:
+    rng_key: the key for the random number generator.
+    target_tree: the tree whose structure to match. Leaves must be arrays.
+    sampler: the noise sampling function, by default ``jax.random.normal``.
+
+  Returns:
+    a random tree with the same structure as ``target_tree``, whose leaves have
+    distribution ``sampler``.
+
+  .. versionadded:: 0.2.1
+  """
+  keys_tree = _tree_rng_keys_split(rng_key, target_tree)
+  return jtu.tree_map(
+      lambda l, k: sampler(k, l.shape),
+      target_tree,
+      keys_tree,
+  )

testbed/google-deepmind__optax/optax/tree_utils/_random_test.py

@@ -0,0 +1,102 @@
+# Copyright 2021 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for optax.tree_utils._random."""
+
+from absl.testing import absltest
+import chex
+import jax
+from jax import tree_util as jtu
+import jax.numpy as jnp
+import numpy as np
+
+from optax import tree_utils as otu
+
+
+class RandomTest(absltest.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    rng = np.random.RandomState(0)
+
+    self.rng_jax = jax.random.PRNGKey(0)
+
+    self.tree_a = (rng.randn(20, 10) + 1j * rng.randn(20, 10), rng.randn(20))
+    self.tree_b = (rng.randn(20, 10), rng.randn(20))
+
+    self.tree_a_dict = jtu.tree_map(
+        jnp.asarray,
+        (
+            1.0,
+            {'k1': 1.0, 'k2': (1.0, 1.0)},
+            1.0
+        )
+    )
+    self.tree_b_dict = jtu.tree_map(
+        jnp.asarray,
+        (
+            1.0,
+            {'k1': 2.0, 'k2': (3.0, 4.0)},
+            5.0
+        )
+    )
+
+    self.array_a = rng.randn(20) + 1j * rng.randn(20)
+    self.array_b = rng.randn(20)
+
+    self.tree_a_dict_jax = jtu.tree_map(jnp.array, self.tree_a_dict)
+    self.tree_b_dict_jax = jtu.tree_map(jnp.array, self.tree_b_dict)
+
+  def test_tree_random_like(self, eps=1e-6):
+    """Test for `tree_random_like`.
+
+    Args:
+      eps: amount of noise.
+
+    Tests that `tree_random_like` generates a tree of the proper structure,
+    that it can be added to a target tree with a small multiplicative factor
+    without errors, and that the resulting addition is close to the original.
+    """
+    rand_tree_a = otu.tree_random_like(self.rng_jax, self.tree_a)
+    rand_tree_b = otu.tree_random_like(self.rng_jax, self.tree_b)
+    rand_tree_a_dict = otu.tree_random_like(self.rng_jax, self.tree_a_dict_jax)
+    rand_tree_b_dict = otu.tree_random_like(self.rng_jax, self.tree_b_dict_jax)
+    rand_array_a = otu.tree_random_like(self.rng_jax, self.array_a)
+    rand_array_b = otu.tree_random_like(self.rng_jax, self.array_b)
+    sum_tree_a = otu.tree_add_scalar_mul(self.tree_a, eps, rand_tree_a)
+    sum_tree_b = otu.tree_add_scalar_mul(self.tree_b, eps, rand_tree_b)
+    sum_tree_a_dict = otu.tree_add_scalar_mul(self.tree_a_dict,
+                                              eps,
+                                              rand_tree_a_dict)
+    sum_tree_b_dict = otu.tree_add_scalar_mul(self.tree_b_dict,
+                                              eps,
+                                              rand_tree_b_dict)
+    sum_array_a = otu.tree_add_scalar_mul(self.array_a, eps, rand_array_a)
+    sum_array_b = otu.tree_add_scalar_mul(self.array_b, eps, rand_array_b)
+    tree_sums = [sum_tree_a,
+                 sum_tree_b,
+                 sum_tree_a_dict,
+                 sum_tree_b_dict,
+                 sum_array_a,
+                 sum_array_b]
+    trees = [self.tree_a,
+             self.tree_b,
+             self.tree_a_dict,
+             self.tree_b_dict,
+             self.array_a,
+             self.array_b]
+    chex.assert_trees_all_close(trees, tree_sums, atol=1e-5)
+
+if __name__ == '__main__':
+  absltest.main()

testbed/google-deepmind__optax/optax/tree_utils/_state_utils.py

@@ -0,0 +1,786 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tools for mapping over optimizer states."""
+
+import dataclasses
+import functools
+import typing
+from typing import Any, Callable, Optional, Protocol, Tuple, Union, cast
+
+import jax
+from optax._src import base
+
+
+@jax.tree_util.register_pytree_node_class
+class _ParamsPlaceholder:
+
+  def tree_flatten(self):
+    return ((), None)
+
+  @classmethod
+  def tree_unflatten(cls, aux, children):
+    del aux, children
+    return cls()
+
+
+@dataclasses.dataclass(frozen=True)
+class NamedTupleKey:
+  """KeyType for a NamedTuple in a tree.
+
+  When using a function ``filtering(path: KeyPath, value: Any) -> bool: ...``
+  in a tree in :func:`optax.tree_utils.tree_get_all_with_path`,
+  :func:`optax.tree_utils.tree_get`, or :func:`optax.tree_utils.tree_set`, can
+  filter the path to check if of the KeyEntry is a NamedTupleKey and then check
+  if the name of named tuple is the one intended to be searched.
+
+  .. seealso:: :class:`jax.tree_util.DictKey`,
+    :class:`jax.tree_util.FlattenedIndexKey`,
+    :class:`jax.tree_util.GetAttrKey`,
+    :class:`jax.tree_util.SequenceKey`,
+    :func:`optax.tree_utils.tree_get_all_with_path`,
+    :func:`optax.tree_utils.tree_get`,
+    :func:`optax.tree_utils.tree_set`,
+
+  Attributes:
+    tuple_name (str): name of the tuple containing the key.
+    name (str): name of the key.
+
+  .. versionadded:: 0.2.2
+  """
+  tuple_name: str
+  name: str
+
+  def __str__(self):
+    return f"{self.tuple_name}.{self.name}"
+
+
+_KeyEntry = Union[
+    jax.tree_util.DictKey,
+    jax.tree_util.FlattenedIndexKey,
+    jax.tree_util.GetAttrKey,
+    jax.tree_util.SequenceKey,
+    NamedTupleKey,
+]
+
+_KeyPath = Tuple[_KeyEntry, ...]
+
+
+@typing.runtime_checkable
+class Initable(Protocol):
+  """An object with an init function."""
+
+  def init(self, params: base.Params) -> base.OptState:
+    """Calling the init for given parameters returns a fresh opt state."""
+
+
+def tree_map_params(
+    initable: Union[
+        Callable[[base.Params], base.OptState],
+        Initable,
+    ],
+    f: Callable[..., Any],
+    state: base.OptState,
+    /,
+    *rest: Any,
+    transform_non_params: Optional[Callable[..., Any]] = None,
+    is_leaf: Optional[Callable[[base.Params], bool]] = None,
+) -> base.OptState:
+  """Apply a callable over all params in the given optimizer state.
+
+  This function exists to help construct partition specs over optimizer
+  states, in the case that a partition spec is already known for the parameters.
+
+  For example, the following will replace all optimizer state parameter trees
+  with copies of the given partition spec instead. The argument
+  `transform_non_params` can be used to replace any remaining fields as
+  required, in this case, we replace those fields by None.
+
+  >>> params, specs = jnp.array(0.), jnp.array(0.)  # Trees with the same shape
+  >>> opt = optax.sgd(1e-3)
+  >>> state = opt.init(params)
+  >>> opt_specs = optax.tree_map_params(
+  ...     opt,
+  ...     lambda _, spec: spec,
+  ...     state,
+  ...     specs,
+  ...     transform_non_params=lambda _: None,
+  ...     )
+
+  Args:
+    initable: A callable taking parameters and returning an optimizer state, or
+      an object with an `init` attribute having the same function.
+    f: A callable that will be applied for all copies of the parameter tree
+      within this optimizer state.
+    state: The optimizer state to map over.
+    *rest: Additional arguments, having the same shape as the parameter tree,
+      that will be passed to f.
+    transform_non_params: An optional function that will be called on all
+      non-parameter fields within the optimizer state.
+    is_leaf: Passed through to `jax.tree.map`. This makes it possible to ignore
+      parts of the parameter tree e.g. when the gradient transformations modify
+      the shape of the original pytree, such as for ``optax.masked``.
+
+  Returns:
+    The result of applying the function f on all trees in the optimizer's state
+    that have the same shape as the parameter tree, along with the given
+    optional extra arguments.
+  """
+
+  # Cast for pytype checks (no-op for other usages).
+  placeholder = cast(base.chex.ArrayTree, _ParamsPlaceholder())
+
+  if isinstance(initable, Initable):
+    initable = cast(Initable, initable)  # for pytype checks
+    state_with_placeholders = initable.init(placeholder)
+  else:
+    state_with_placeholders = initable(placeholder)
+
+  def map_params(maybe_placeholder_value, value):
+    if isinstance(maybe_placeholder_value, _ParamsPlaceholder):
+      return jax.tree_util.tree_map(f, value, *rest, is_leaf=is_leaf)
+    elif transform_non_params is not None:
+      return transform_non_params(value)
+    else:
+      return value
+
+  return jax.tree_util.tree_map(
+      map_params,
+      state_with_placeholders,
+      state,
+      is_leaf=lambda v: isinstance(v, _ParamsPlaceholder),
+  )
+
+
+def tree_get_all_with_path(
+    tree: base.PyTree,
+    key: Any,
+    filtering: Optional[Callable[[_KeyPath, Any], bool]] = None,
+) -> list[tuple[_KeyPath, Any]]:
+  # pylint: disable=line-too-long
+  r"""Extract values of a pytree matching a given key.
+
+  Search in a pytree ``tree`` for a specific ``key`` (which can be a key
+  from a dictionary, a field from a NamedTuple or the name of a NamedTuple).
+
+  That key/field ``key`` may appear more than once in ``tree``. So this function
+  returns a list of all values corresponding to ``key`` with the path to
+  that value. The path is a sequence of ``KeyEntry`` that can be transformed in
+  readable format using :func:`jax.tree_util.keystr`, see the example below.
+
+  Examples:
+
+    Basic usage
+
+      >>> import jax.numpy as jnp
+      >>> import optax
+      >>> params = jnp.array([1., 2., 3.])
+      >>> solver = optax.inject_hyperparams(optax.sgd)(
+      ...   learning_rate=lambda count: 1/(count+1)
+      ... )
+      >>> state = solver.init(params)
+      >>> found_values_with_path = optax.tree_utils.tree_get_all_with_path(
+      ...   state, 'learning_rate'
+      ... )
+      >>> print(
+      ... *[(jax.tree_util.keystr(p), v) for p, v in found_values_with_path],
+      ... sep="\n",
+      ... )
+      ("InjectStatefulHyperparamsState.hyperparams['learning_rate']", Array(1., dtype=float32))
+      ("InjectStatefulHyperparamsState.hyperparams_states['learning_rate']", WrappedScheduleState(count=Array(0, dtype=int32)))
+
+    Usage with a filtering operation
+
+      >>> import jax.numpy as jnp
+      >>> import optax
+      >>> params = jnp.array([1., 2., 3.])
+      >>> solver = optax.inject_hyperparams(optax.sgd)(
+      ...   learning_rate=lambda count: 1/(count+1)
+      ... )
+      >>> state = solver.init(params)
+      >>> filtering = lambda path, value: isinstance(value, tuple)
+      >>> found_values_with_path = optax.tree_utils.tree_get_all_with_path(
+      ...   state, 'learning_rate', filtering
+      ... )
+      >>> print(
+      ... *[(jax.tree_util.keystr(p), v) for p, v in found_values_with_path],
+      ... sep="\n",
+      ... )
+      ("InjectStatefulHyperparamsState.hyperparams_states['learning_rate']", WrappedScheduleState(count=Array(0, dtype=int32)))
+
+  .. seealso:: :func:`optax.tree_utils.tree_get`,
+    :func:`optax.tree_utils.tree_set`
+
+  Args:
+    tree: tree to search in.
+    key: keyword or field to search in tree for.
+    filtering: optional callable to further filter values in tree that match the
+      key. ``filtering(path: Key_Path, value: Any) -> bool: ...``
+      takes as arguments both the path to the value (as returned by
+      :func:`optax.tree_utils.tree_get_all_with_path`) and the
+      value that match the given key.
+
+  Returns:
+    values_with_path
+      list of tuples where each tuple is of the form
+      (``path_to_value``, ``value``). Here ``value`` is one entry of the tree
+      that corresponds to the ``key``, and ``path_to_value`` is a tuple of
+      `KeyEntry` that is a tuple of :class:`jax.tree_util.DictKey`,
+      :class:`jax.tree_util.FlattenedIndexKey`,
+      :class:`jax.tree_util.GetAttrKey`,
+      :class:`jax.tree_util.SequenceKey`, or
+      :class:`optax.tree_utils.NamedTupleKey`.
+
+  .. versionadded:: 0.2.2
+  """
+  # pylint: enable=line-too-long
+  found_values_with_path = _tree_get_all_with_path(tree, key)
+  if filtering:
+    found_values_with_path = [
+        (path, value)
+        for path, value in found_values_with_path
+        if filtering(path, value)
+    ]
+  return found_values_with_path
+
+
+def tree_get(
+    tree: base.PyTree,
+    key: Any,
+    default: Optional[Any] = None,
+    filtering: Optional[Callable[[_KeyPath, Any], bool]] = None,
+) -> Any:
+  # pylint: disable=line-too-long
+  """Extract a value from a pytree matching a given key.
+
+  Search in the ``tree`` for a specific ``key`` (which can be a key
+  from a dictionary, a field from a NamedTuple or the name of a NamedTuple).
+
+  If the ``tree`` does not containt ``key`` returns ``default``.
+
+  Raises a ``KeyError`` if multiple values of ``key`` are found in ``tree``.
+
+  Generally, you may first get all pairs ``(path_to_value, value)`` for a given
+  ``key`` using :func:`optax.tree_utils.tree_get_all_with_path`. You may then 
+  define a filtering operation
+  ``filtering(path: Key_Path, value: Any) -> bool: ...`` that enables you to
+  select the specific values you wanted to fetch by looking at the type of the
+  value, or looking at the path to that value.
+  Note that contrarily to the paths returned by
+  :func:`jax.tree_util.tree_leaves_with_path` the paths analyzed by the
+  filtering operation in :func:`optax.tree_utils.tree_get_all_with_path`,
+  :func:`optax.tree_utils.tree_get`, or :func:`optax.tree_utils.tree_set` detail
+  the names of the named tuples considered in the path. Concretely, if the value
+  considered is in the attribute ``key`` of a named tuple called
+  ``MyNamedTuple`` the last element of the path will be a
+  :class:`optax.tree_utils.NamedTupleKey` containing both ``name=key`` and
+  ``tuple_name='MyNamedTuple'``. That way you may distinguish between identical
+  values in different named tuples (arising for example when chaining
+  transformations in optax). See the last example below.
+
+  .. seealso:: :func:`optax.tree_utils.tree_get_all_with_path`,
+    :func:`optax.tree_utils.tree_set`
+
+  Examples:
+
+    Basic usage
+
+      >>> import jax.numpy as jnp
+      >>> import optax
+      >>> params = jnp.array([1., 2., 3.])
+      >>> opt = optax.adam(learning_rate=1.)
+      >>> state = opt.init(params)
+      >>> count = optax.tree_utils.tree_get(state, 'count')
+      >>> print(count)
+      0
+
+    Usage with a filtering operation
+
+      >>> import jax.numpy as jnp
+      >>> import optax
+      >>> params = jnp.array([1., 2., 3.])
+      >>> opt = optax.inject_hyperparams(optax.sgd)(
+      ...   learning_rate=lambda count: 1/(count+1)
+      ... )
+      >>> state = opt.init(params)
+      >>> filtering = lambda path, value: isinstance(value, jnp.ndarray)
+      >>> lr = optax.tree_utils.tree_get(
+      ...   state, 'learning_rate', filtering=filtering
+      ... )
+      >>> print(lr)
+      1.0
+
+    Extracting a named tuple by its name
+
+      >>> params = jnp.array([1., 2., 3.])
+      >>> opt = optax.chain(
+      ...     optax.add_noise(1.0, 0.9, 0), optax.scale_by_adam()
+      ... )
+      >>> state = opt.init(params)
+      >>> noise_state = optax.tree_utils.tree_get(state, 'AddNoiseState')
+      >>> print(noise_state)
+      AddNoiseState(count=Array(0, dtype=int32), rng_key=Array([0, 0], dtype=uint32))
+
+    Differentiating between two values by the name of their named tuples.
+
+      >>> import jax.numpy as jnp
+      >>> import optax
+      >>> params = jnp.array([1., 2., 3.])
+      >>> opt = optax.chain(
+      ...   optax.add_noise(1.0, 0.9, 0), optax.scale_by_adam()
+      ... )
+      >>> state = opt.init(params)
+      >>> filtering = (
+      ...      lambda p, v: isinstance(p[-1], optax.tree_utils.NamedTupleKey)
+      ...      and p[-1].tuple_name == 'ScaleByAdamState'
+      ... )
+      >>> count = optax.tree_utils.tree_get(state, 'count', filtering=filtering)
+      >>> print(count)
+      0
+
+  Args:
+    tree: tree to search in.
+    key: keyword or field to search in ``tree`` for.
+    default: default value to return if ``key`` is not found in ``tree``.
+    filtering: optional callable to further filter values in ``tree`` that match
+      the ``key``. ``filtering(path: Key_Path, value: Any) -> bool: ...``
+      takes as arguments both the path to the value (as returned by
+      :func:`optax.tree_utils.tree_get_all_with_path`) and the
+      value that match the given key.
+
+  Returns:
+    value
+      value in ``tree`` matching the given ``key``. If none are
+      found return ``default`` value. If multiple are found raises an error.
+
+  Raises:
+    KeyError: If multiple values of ``key`` are found in ``tree``.
+
+  .. versionadded:: 0.2.2
+  """
+  # pylint: enable=line-too-long
+  found_values_with_path = tree_get_all_with_path(
+      tree, key, filtering=filtering
+  )
+  if len(found_values_with_path) > 1:
+    raise KeyError(f"Found multiple values for '{key}' in {tree}.")
+  elif not found_values_with_path:
+    return default
+  else:
+    return found_values_with_path[0][1]
+
+
+def tree_set(
+    tree: base.PyTree,
+    filtering: Optional[Callable[[_KeyPath, Any], bool]] = None,
+    /,
+    **kwargs: Any,
+) -> base.PyTree:
+  # pylint: disable=line-too-long
+  r"""Creates a copy of tree with some values replaced as specified by kwargs.
+
+  Search in the ``tree`` for ``keys`` in ``**kwargs`` (which can be a key
+  from a dictionary, a field from a NamedTuple or the name of a NamedTuple).
+  If such a key is found, replace the corresponding value with the one given in
+  ``**kwargs``.
+
+  Raises a ``KeyError`` if some keys in ``**kwargs`` are not present in the
+  tree.
+
+  .. note:: The recommended usage to inject hyperparameters schedules is through
+    :func:`optax.inject_hyperparams`. This function is a helper for other
+    purposes.
+
+  Examples:
+
+    Basic usage
+
+      >>> import jax.numpy as jnp
+      >>> import optax
+      >>> params = jnp.array([1., 2., 3.])
+      >>> opt = optax.adam(learning_rate=1.)
+      >>> state = opt.init(params)
+      >>> print(state)
+      (ScaleByAdamState(count=Array(0, dtype=int32), mu=Array([0., 0., 0.], dtype=float32), nu=Array([0., 0., 0.], dtype=float32)), EmptyState())
+      >>> new_state = optax.tree_utils.tree_set(state, count=2.)
+      >>> print(new_state)
+      (ScaleByAdamState(count=2.0, mu=Array([0., 0., 0.], dtype=float32), nu=Array([0., 0., 0.], dtype=float32)), EmptyState())
+
+    Usage with a filtering operation
+
+      >>> import jax.numpy as jnp
+      >>> import optax
+      >>> params = jnp.array([1., 2., 3.])
+      >>> opt = optax.inject_hyperparams(optax.sgd)(
+      ...     learning_rate=lambda count: 1/(count+1)
+      ...  )
+      >>> state = opt.init(params)
+      >>> print(state)
+      InjectStatefulHyperparamsState(count=Array(0, dtype=int32), hyperparams={'learning_rate': Array(1., dtype=float32)}, hyperparams_states={'learning_rate': WrappedScheduleState(count=Array(0, dtype=int32))}, inner_state=(EmptyState(), EmptyState()))
+      >>> filtering = lambda path, value: isinstance(value, jnp.ndarray)
+      >>> new_state = optax.tree_utils.tree_set(
+      ...   state, filtering, learning_rate=jnp.asarray(0.1)
+      ... )
+      >>> print(new_state)
+      InjectStatefulHyperparamsState(count=Array(0, dtype=int32), hyperparams={'learning_rate': Array(0.1, dtype=float32, weak_type=True)}, hyperparams_states={'learning_rate': WrappedScheduleState(count=Array(0, dtype=int32))}, inner_state=(EmptyState(), EmptyState()))
+
+  .. seealso:: :func:`optax.tree_utils.tree_get_all_with_path`,
+    :func:`optax.tree_utils.tree_get`
+
+  Args:
+    tree: pytree whose values are to be replaced.
+    filtering: optional callable to further filter values in ``tree`` that match
+      the keys to replace.
+      ``filtering(path: Key_Path, value: Any) -> bool: ...``
+      takes as arguments both the path to the value (as returned by
+      :func:`optax.tree_utils.tree_get_all_with_path`) and the
+      value that match a given key.
+    **kwargs: dictionary of keys with values to replace in ``tree``.
+
+  Returns:
+    new_tree
+      new pytree with the same structure as ``tree``. For each element in
+      ``tree`` whose key/field matches a key in ``**kwargs``, its value is
+      set by the corresponding value in ``**kwargs``.
+
+  Raises:
+    KeyError: If no values of some key in ``**kwargs`` are found in ``tree``
+      or none of the values satisfy the filtering operation.
+
+  .. versionadded:: 0.2.2
+  """
+  # pylint: enable=line-too-long
+
+  # First check if the keys are present in the tree
+  for key in kwargs:
+    found_values_with_path = tree_get_all_with_path(tree, key, filtering)
+    if not found_values_with_path:
+      if filtering:
+        raise KeyError(
+            f"Found no values matching '{key}' given the filtering operation in"
+            f" {tree}"
+        )
+      else:
+        raise KeyError(f"Found no values matching '{key}' in {tree}")
+
+  has_any_key = functools.partial(_node_has_keys, keys=tuple(kwargs.keys()))
+
+  def _replace(path: _KeyPath, node: Any) -> Any:
+    """Replace a node with a new node whose values are updated."""
+    if has_any_key(node):
+      if (
+          _is_named_tuple(node)
+          and (node.__class__.__name__ in kwargs)
+          and (filtering is None or filtering(path, node))
+      ):
+        # The node itself is a named tuple we wanted to replace
+        return kwargs[node.__class__.__name__]
+      else:
+        # The node contains one of the keys we want to replace
+        children_with_path = _get_children_with_path(path, node)
+        new_children_with_keys = {}
+        for child_path, child in children_with_path:
+          # Scan each child of that node
+          key = _get_key(child_path[-1])
+          if key in kwargs and (
+              filtering is None or filtering(child_path, child)
+          ):
+            # If the child matches a given key given the filtering operation
+            # replaces with the new value
+            new_children_with_keys.update({key: kwargs[key]})
+          else:
+            if (
+                isinstance(child, tuple)
+                or isinstance(child, dict)
+                or isinstance(child, list)
+            ):
+              # If the child is itself a pytree, further search in the child to
+              # replace the given value
+              new_children_with_keys.update({key: _replace(child_path, child)})
+            else:
+              # If the child is just a leaf that does not contain the key or
+              # satisfies the filtering operation, just return the child.
+              new_children_with_keys.update({key: child})
+        return _set_children(node, new_children_with_keys)
+    else:
+      return node
+
+  # Mimics jax.tree_util.tree_map_with_path(_replace, tree, is_leaf)
+  # except that the paths we consider can contain NamedTupleKeys
+  _, treedef = jax.tree_util.tree_flatten(tree, is_leaf=has_any_key)
+  tree_leaves_with_path = _tree_leaves_with_named_tuple_path(
+      tree, is_leaf=has_any_key
+  )
+  tree_leaves_with_path = list(zip(*tree_leaves_with_path))
+  new_tree = treedef.unflatten(
+      _replace(*xs) for xs in zip(*tree_leaves_with_path)
+  )
+  return new_tree
+
+
+def _tree_get_all_with_path(
+    tree: base.PyTree, key: str
+) -> list[tuple[_KeyPath, Any]]:
+  """Get all values of a pytree matching a given key.
+
+  Private function called recursively, see
+  :func:`optax.tree_utils.tree_get_all_with_path` for public api.
+
+  Args:
+    tree: tree to search in.
+    key: keyword or name to search in tree for.
+
+  Returns:
+    values_with_path
+      list of tuples where each tuple is of the form
+      (``path_to_value``, ``value``). Here ``value`` is one entry of the tree
+      that corresponds to the ``key``, and ``path_to_value`` is a tuple of
+      `KeyEntry` that is a tuple of :class:`jax.tree_util.DictKey`,
+      :class:`jax.tree_util.FlattenedIndexKey`,
+      :class:`jax.tree_util.GetAttrKey`,
+      :class:`jax.tree_util.SequenceKey`, or
+      :class:`optax.tree_utils.NamedTupleKey`.
+  """
+
+  # Get subtrees containing a field with the given key
+  has_key = functools.partial(_node_has_keys, keys=(key,))
+  leaves_or_subtrees_with_path = _tree_leaves_with_named_tuple_path(
+      tree, is_leaf=has_key
+  )
+  subtrees_with_path = [
+      (path, leaf_or_subtree)
+      for path, leaf_or_subtree in leaves_or_subtrees_with_path
+      if has_key(leaf_or_subtree)
+  ]
+
+  # Get (path_to_value, value) for the subtrees found
+  found_values_with_path = [
+      _flatten_to_key(path, subtree, key)
+      for path, subtree in subtrees_with_path
+  ]
+
+  # Further search in subtrees for additional values
+  for path, subtree in subtrees_with_path:
+    children_with_path = _get_children_with_path(path, subtree)
+    for path, child in children_with_path:
+      new_values_with_path = _tree_get_all_with_path(child, key)
+      new_values_with_path = [
+          ((*path, *new_path), new_value)
+          for new_path, new_value in new_values_with_path
+      ]
+      found_values_with_path += new_values_with_path
+  return found_values_with_path
+
+
+def _is_named_tuple(x):
+  return (
+      isinstance(x, tuple)
+      and hasattr(x, "_fields")
+      and hasattr(x, "__class__")
+      and hasattr(x.__class__, "__name__")
+  )
+
+
+def _tree_leaves_with_named_tuple_path(
+    tree: base.PyTree,
+    is_leaf: Optional[
+        Callable[
+            [
+                Any,
+            ],
+            bool,
+        ]
+    ] = None,
+) -> list[tuple[_KeyPath, Any]]:
+  """Get leaves of a tree with their path.
+
+  Essentially the same as :func:`jax.tree_util.tree_leaves_with_path`.
+  The difference is that for each attribute of a named tuple we add to the given
+  entry the name of the tuple. This facilitates getting/setting values in a
+  pytree by filtering for attributes in specific states (different named tuples)
+  that have otherwise the same name and type.
+  See :func:`optax.tree_utils.tree_get` for a concrete example.
+
+  Args:
+    tree: pytree to extract leaves of.
+    is_leaf: callable to stop expanding the tree at a node that satisfies
+      is_leaf(node) == True.
+
+  Returns:
+    list of (path_to_leaf, leaf) for all leaves in the tree
+    (or nodes satisfying is_leaf(node) == True).
+  """
+  is_leaf_ = is_leaf if is_leaf else lambda _: False
+  tree_leaves_with_path = jax.tree_util.tree_leaves_with_path(
+      tree, is_leaf=lambda x: is_leaf_(x) or _is_named_tuple(x)
+  )
+  named_tree_leaves_with_path = []
+  for path, node in tree_leaves_with_path:
+    if is_leaf_(node) or not _is_named_tuple(node):
+      named_tree_leaves_with_path.append((path, node))
+    else:
+      for field in node._fields:
+        child_leaves_with_path = _tree_leaves_with_named_tuple_path(
+            getattr(node, field), is_leaf
+        )
+        child_leaves_with_path = [
+            (
+                (
+                    *path,
+                    NamedTupleKey(node.__class__.__name__, field),
+                    *child_path,
+                ),
+                child_value,
+            )
+            for child_path, child_value in child_leaves_with_path
+        ]
+        named_tree_leaves_with_path = (
+            named_tree_leaves_with_path + child_leaves_with_path
+        )
+  return named_tree_leaves_with_path
+
+
+def _node_has_keys(node: Any, keys: tuple[Any, ...]) -> bool:
+  """Filter for nodes in a tree whose field/key/name matches the given key.
+
+  Private method used in :func:`optax.tree_utils.tree_get_all_with_path` and in
+  :func:`optax.tree_utils.tree_set`.
+
+  Args:
+    node: node in a pytree.
+    keys: keys to search for in the node.
+
+  Returns:
+    whether the node has one of the given keys.
+  """
+  if _is_named_tuple(node) and any(key in node._fields for key in keys):
+    return True
+  elif _is_named_tuple(node) and (node.__class__.__name__ in keys):
+    return True
+  elif isinstance(node, dict) and any(key in node for key in keys):
+    return True
+  else:
+    return False
+
+
+def _flatten_to_key(
+    path: _KeyPath, node: Any, key: Any
+) -> tuple[_KeyPath, Any]:
+  """Flatten a node with a field/key/name matching given key.
+
+  Private method used in :func:`optax.tree_utils.tree_get_all_with_path`.
+
+  Args:
+    path: path to the node in a pytree.
+    node: node in a pytree.
+    key: key to reach for in the node.
+
+  Returns:
+    (path_to_key, key_node)
+      if key is a key/field of the node,
+      ``path_to_key = (*path_to_node, key_path)``, ``key_node = node[key]``,
+      otherwise returns the path and node as they are.
+  """
+  if _is_named_tuple(node):
+    if key == node.__class__.__name__:
+      return (path, node)
+    else:
+      path_to_key = (*path, NamedTupleKey(node.__class__.__name__, key))
+      return (path_to_key, getattr(node, key))
+  elif isinstance(node, dict) and key in node:
+    return (*path, jax.tree_util.DictKey(key)), node[key]
+  else:
+    return path, node
+
+
+def _get_children_with_path(
+    path: _KeyPath, node: Any
+) -> list[tuple[_KeyPath, Any]]:
+  """Get children of a node.
+
+  Private method used in :func:`optax.tree_utils.tree_get_all_with_path` and in
+  :func:`optax.tree_utils.tree_set`. In particular, it is tailored for
+  nodes that are NamedTuple or dict.
+
+  Args:
+    path: path to the node in a pytree.
+    node: node in a pytree.
+
+  Returns:
+    list of (path_to_child, child) for child a child in nodes.
+
+  Raises:
+    ValueError if the given node is not a NamedTuple or a dict
+  """
+  if _is_named_tuple(node):
+    return [
+        (
+            (*path, NamedTupleKey(node.__class__.__name__, field)),
+            getattr(node, field),
+        )
+        for field in node._fields
+    ]
+  elif isinstance(node, dict):
+    return [
+        ((*path, jax.tree_util.DictKey(key)), value)
+        for key, value in node.items()
+    ]
+  else:
+    raise ValueError(
+        f"Subtree must be a dict or a NamedTuple. Got {type(node)}"
+    )
+
+
+def _set_children(node: Any, children_with_keys: dict[Any, Any]) -> Any:
+  """Set children of a node.
+
+  Private method used in :func:`optax.tree_utils.tree_set`.
+  In particular, it is tailored for nodes that are NamedTuple or dict.
+
+  Args:
+    node: node in a pytree.
+    children_with_keys: children of the node with associated keys
+
+  Returns:
+    new_node whose fields/keys are replaced by the ones given in
+    children_with_keys.
+
+  Raises:
+    ValueError if the given node is not a NamedTuple or a dict
+  """
+  if _is_named_tuple(node):
+    return node._replace(**children_with_keys)
+  elif isinstance(node, dict):
+    return children_with_keys
+  else:
+    raise ValueError(
+        f"Subtree must be a dict or a NamedTuple. Got {type(node)}"
+    )
+
+
+def _get_key(key: _KeyEntry) -> Union[int, str]:
+  """Convert a ``KeyEntry``` to a usual type."""
+  if isinstance(key, jax.tree_util.DictKey):
+    if isinstance(key.key, (str, int)):
+      return key.key
+    raise KeyError("Hashable keys not supported")
+  if isinstance(key, jax.tree_util.FlattenedIndexKey):
+    return key.key  # int.
+  if isinstance(key, jax.tree_util.GetAttrKey):
+    return key.name  # str.
+  if isinstance(key, jax.tree_util.SequenceKey):
+    return key.idx  # int.
+  if isinstance(key, NamedTupleKey):
+    return key.name  # str.
+  raise KeyError(f"Tree key '{key}' of type '{type(key)}' not valid.")

testbed/google-deepmind__optax/optax/tree_utils/_state_utils_test.py

@@ -0,0 +1,599 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Tests for _state_utils."""
+
+import dataclasses
+from typing import Optional, TypedDict, cast
+
+from absl.testing import absltest
+import chex
+import jax
+import jax.numpy as jnp
+import jax.tree_util as jtu
+from optax._src import alias
+from optax._src import base
+from optax._src import combine
+from optax._src import transform
+from optax.schedules import _inject
+from optax.schedules import _schedule
+from optax.tree_utils import _state_utils
+
+
+@dataclasses.dataclass
+class FakeShardSpec:
+  sharding_axis: Optional[int]
+
+
+class ScaleByAdamStateDict(TypedDict):
+  """An opt state that uses dictionaries instead of classes."""
+
+  count: chex.Array
+  params: TypedDict('Params', {'mu': chex.ArrayTree, 'nu': chex.ArrayTree})
+
+
+def _scale_by_adam_with_dicts():
+  """An implementation of adam using dictionary-based opt states."""
+
+  t = transform.scale_by_adam()
+
+  def init(params):
+    state = t.init(params)
+    state = cast(transform.ScaleByAdamState, state)
+
+    return ScaleByAdamStateDict(
+        count=state.count,
+        params={'mu': state.mu, 'nu': state.nu},
+    )
+
+  def update(updates, state, params=None):
+    state = transform.ScaleByAdamState(
+        count=state['count'],
+        mu=state['params']['mu'],
+        nu=state['params']['nu'],
+    )
+
+    _, state = t.update(updates, state, params)
+    state = cast(transform.ScaleByAdamState, state)
+    return ScaleByAdamStateDict(
+        count=state.count,
+        params={'mu': state.mu, 'nu': state.nu},
+    )
+
+  return base.GradientTransformation(init, update)
+
+
+class StateUtilsTest(absltest.TestCase):
+
+  def test_dict_based_optimizers(self):
+    """Test we can map over params also for optimizer states using dicts."""
+    opt = combine.chain(
+        _scale_by_adam_with_dicts(),
+        transform.add_decayed_weights(1e-3),
+    )
+
+    params = _fake_params()
+    params_sharding_spec = _fake_param_sharding()
+    opt_state = opt.init(params)
+
+    opt_state_sharding_spec = _state_utils.tree_map_params(
+        opt,
+        lambda _, spec: spec,
+        opt_state,
+        params_sharding_spec,
+        transform_non_params=lambda _: FakeShardSpec(None),
+    )
+
+    expected = (
+        {
+            'count': FakeShardSpec(sharding_axis=None),
+            'params': {
+                'mu': {
+                    'my/fake/module': {
+                        'b': FakeShardSpec(sharding_axis=1),
+                        'w': FakeShardSpec(sharding_axis=0),
+                    },
+                    'my/other/fake/module': {
+                        'b': FakeShardSpec(sharding_axis=3),
+                        'w': FakeShardSpec(sharding_axis=2),
+                    },
+                },
+                'nu': {
+                    'my/fake/module': {
+                        'b': FakeShardSpec(sharding_axis=1),
+                        'w': FakeShardSpec(sharding_axis=0),
+                    },
+                    'my/other/fake/module': {
+                        'b': FakeShardSpec(sharding_axis=3),
+                        'w': FakeShardSpec(sharding_axis=2),
+                    },
+                },
+            },
+        },
+        base.EmptyState(),
+    )
+
+    self.assertEqual(expected, opt_state_sharding_spec)
+
+  def test_state_chex_dataclass(self):
+    @chex.dataclass
+    class Foo:
+      count: int
+      v: chex.ArrayTree
+
+    def init(params):
+      return Foo(count=0, v=params)
+
+    params = {
+        'w': 0,
+    }
+
+    state = init(params)
+    state = _state_utils.tree_map_params(init, lambda v: v + 1, state)
+    state = cast(Foo, state)
+
+    self.assertEqual(int(state.count), 0)
+    self.assertEqual(state.v, {'w': jnp.array(1)})
+
+  def test_adam(self):
+    params = _fake_params()
+    params_sharding_spec = _fake_param_sharding()
+
+    opt = alias.adam(1e-4)
+    opt_state = opt.init(params)
+
+    opt_state_sharding_spec = _state_utils.tree_map_params(
+        opt,
+        lambda _, spec: spec,
+        opt_state,
+        params_sharding_spec,
+        transform_non_params=lambda _: FakeShardSpec(None),
+    )
+
+    expected = (
+        transform.ScaleByAdamState(  # pytype:disable=wrong-arg-types
+            count=FakeShardSpec(sharding_axis=None),
+            mu={
+                'my/fake/module': {
+                    'w': FakeShardSpec(sharding_axis=0),
+                    'b': FakeShardSpec(sharding_axis=1),
+                },
+                'my/other/fake/module': {
+                    'w': FakeShardSpec(sharding_axis=2),
+                    'b': FakeShardSpec(sharding_axis=3),
+                },
+            },
+            nu={
+                'my/fake/module': {
+                    'w': FakeShardSpec(sharding_axis=0),
+                    'b': FakeShardSpec(sharding_axis=1),
+                },
+                'my/other/fake/module': {
+                    'w': FakeShardSpec(sharding_axis=2),
+                    'b': FakeShardSpec(sharding_axis=3),
+                },
+            },
+        ),
+        base.EmptyState(),
+    )
+
+    self.assertEqual(expected, opt_state_sharding_spec)
+
+  def test_inject_hparams(self):
+    opt = _inject.inject_hyperparams(alias.adamw)(learning_rate=1e-3)
+
+    params = _fake_params()
+    state = opt.init(params)
+    state = _state_utils.tree_map_params(opt, lambda v: v + 1, state)
+    state = cast(_inject.InjectHyperparamsState, state)
+
+    self.assertEqual(1e-3, state.hyperparams['learning_rate'])
+    params_plus_one = jtu.tree_map(lambda v: v + 1, params)
+    mu = getattr(state.inner_state[0], 'mu')
+    chex.assert_trees_all_close(mu, params_plus_one)
+
+  def test_map_params_to_none(self):
+    opt = alias.adagrad(1e-4)
+
+    params = {'a': jnp.zeros((1, 2))}
+    state = opt.init(params)
+    state = _state_utils.tree_map_params(opt, lambda _: None, state)
+    self.assertEqual(
+        state,
+        (
+            transform.ScaleByRssState(sum_of_squares={'a': None}),
+            base.EmptyState(),
+        ),
+    )
+
+  def test_map_non_params_to_none(self):
+    """Test for dangerous edge-cases in tree when returning None values."""
+
+    opt = alias.adam(_schedule.linear_schedule(1e-2, 1e-4, 10))
+
+    params = {'a': jnp.zeros((1, 2))}
+    state = opt.init(params)
+
+    state = _state_utils.tree_map_params(
+        opt, lambda v: 1, state, transform_non_params=lambda _: None
+    )
+
+    expected = (
+        transform.ScaleByAdamState(  # pytype:disable=wrong-arg-types
+            count=None,
+            mu={'a': 1},
+            nu={'a': 1},
+        ),
+        transform.ScaleByScheduleState(  # pytype:disable=wrong-arg-types
+            count=None
+        ),
+    )
+    self.assertEqual(state, expected)
+
+  def test_tree_get_all_with_path(self):
+    params = jnp.array([1.0, 2.0, 3.0])
+
+    with self.subTest('Test with flat tree'):
+      tree = ()
+      found_values = _state_utils.tree_get_all_with_path(tree, 'foo')
+      self.assertEmpty(found_values)
+      tree = jnp.array([1.0, 2.0, 3.0])
+      found_values = _state_utils.tree_get_all_with_path(tree, 'foo')
+      self.assertEmpty(found_values)
+
+    with self.subTest('Test with single value in state'):
+      key = 'count'
+      opt = transform.scale_by_adam()
+      state = opt.init(params)
+      found_values = _state_utils.tree_get_all_with_path(state, key)
+      expected_result = [(
+          (_state_utils.NamedTupleKey('ScaleByAdamState', 'count'),),
+          jnp.array(0.0),
+      )]
+      self.assertEqual(found_values, expected_result)
+
+    with self.subTest('Test with no value in state'):
+      key = 'apple'
+      opt = alias.adam(learning_rate=1.0)
+      state = opt.init(params)
+      found_values = _state_utils.tree_get_all_with_path(state, key)
+      self.assertEmpty(found_values)
+
+    with self.subTest('Test with multiple values in state'):
+      key = 'learning_rate'
+      opt = combine.chain(
+          _inject.inject_hyperparams(alias.sgd)(learning_rate=1.0),
+          combine.chain(
+              alias.adam(learning_rate=1.0),
+              _inject.inject_hyperparams(alias.adam)(learning_rate=1e-4),
+          ),
+      )
+      state = opt.init(params)
+      found_values = _state_utils.tree_get_all_with_path(state, key)
+      expected_result = [
+          (
+              (
+                  jtu.SequenceKey(idx=0),
+                  _state_utils.NamedTupleKey(
+                      'InjectStatefulHyperparamsState', 'hyperparams'
+                  ),
+                  jtu.DictKey(key='learning_rate'),
+              ),
+              jnp.array(1.0),
+          ),
+          (
+              (
+                  jtu.SequenceKey(idx=1),
+                  jtu.SequenceKey(idx=1),
+                  _state_utils.NamedTupleKey(
+                      'InjectStatefulHyperparamsState', 'hyperparams'
+                  ),
+                  jtu.DictKey(key='learning_rate'),
+              ),
+              jnp.array(1e-4),
+          ),
+      ]
+      self.assertEqual(found_values, expected_result)
+
+    with self.subTest('Test with optional filtering'):
+      state = dict(hparams=dict(learning_rate=1.0), learning_rate='foo')
+
+      # Without filtering two values are found
+      found_values = _state_utils.tree_get_all_with_path(state, 'learning_rate')
+      self.assertLen(found_values, 2)
+
+      # With filtering only the float entry is returned
+      filtering = lambda _, value: isinstance(value, float)
+      found_values = _state_utils.tree_get_all_with_path(
+          state, 'learning_rate', filtering=filtering
+      )
+      self.assertLen(found_values, 1)
+      expected_result = [(
+          (jtu.DictKey(key='hparams'), jtu.DictKey(key='learning_rate')),
+          1.0,
+      )]
+      self.assertEqual(found_values, expected_result)
+
+    with self.subTest('Test to get a subtree (here hyperparams_states)'):
+      opt = _inject.inject_hyperparams(alias.sgd)(learning_rate=lambda x: x)
+      filtering = lambda _, value: isinstance(value, tuple)
+      state = opt.init(params)
+      found_values = _state_utils.tree_get_all_with_path(
+          state, 'learning_rate', filtering=filtering
+      )
+      expected_result = [(
+          (
+              _state_utils.NamedTupleKey(
+                  'InjectStatefulHyperparamsState', 'hyperparams_states'
+              ),
+              jtu.DictKey(key='learning_rate'),
+          ),
+          _inject.WrappedScheduleState(
+              count=jnp.array(0, dtype=jnp.dtype('int32'))
+          ),
+      )]
+      self.assertEqual(found_values, expected_result)
+
+    with self.subTest('Test with nested tree containing a key'):
+      tree = dict(a=dict(a=1.0))
+      found_values = _state_utils.tree_get_all_with_path(tree, 'a')
+      expected_result = [
+          ((jtu.DictKey(key='a'),), {'a': 1.0}),
+          ((jtu.DictKey(key='a'), jtu.DictKey(key='a')), 1.0),
+      ]
+      self.assertEqual(found_values, expected_result)
+
+  def test_tree_get(self):
+    params = jnp.array([1.0, 2.0, 3.0])
+
+    with self.subTest('Test with unique value matching the key'):
+      solver = _inject.inject_hyperparams(alias.sgd)(learning_rate=42.0)
+      state = solver.init(params)
+      lr = _state_utils.tree_get(state, 'learning_rate')
+      self.assertEqual(lr, 42.0)
+
+    with self.subTest('Test with no value matching the key'):
+      solver = _inject.inject_hyperparams(alias.sgd)(learning_rate=42.0)
+      state = solver.init(params)
+      ema = _state_utils.tree_get(state, 'ema')
+      self.assertIsNone(ema)
+      ema = _state_utils.tree_get(state, 'ema', default=7.0)
+      self.assertEqual(ema, 7.0)
+
+    with self.subTest('Test with multiple values matching the key'):
+      solver = combine.chain(
+          _inject.inject_hyperparams(alias.sgd)(learning_rate=42.0),
+          _inject.inject_hyperparams(alias.sgd)(learning_rate=42.0),
+      )
+      state = solver.init(params)
+      self.assertRaises(KeyError, _state_utils.tree_get, state, 'learning_rate')
+
+    with self.subTest('Test jitted tree_get'):
+      opt = _inject.inject_hyperparams(alias.sgd)(
+          learning_rate=lambda x: 1 / (x + 1)
+      )
+      state = opt.init(params)
+      filtering = lambda _, value: isinstance(value, jnp.ndarray)
+
+      @jax.jit
+      def get_learning_rate(state):
+        return _state_utils.tree_get(
+            state, 'learning_rate', filtering=filtering
+        )
+
+      for i in range(4):
+        # we simply update state, we don't care about updates.
+        _, state = opt.update(params, state)
+        lr = get_learning_rate(state)
+        self.assertEqual(lr, 1 / (i + 1))
+
+    with self.subTest('Test with optional filtering'):
+      state = dict(hparams=dict(learning_rate=1.0), learning_rate='foo')
+
+      # Without filtering raises an error
+      self.assertRaises(KeyError, _state_utils.tree_get, state, 'learning_rate')
+
+      # With filtering, fetches the float entry
+      filtering = lambda path, value: isinstance(value, float)
+      lr = _state_utils.tree_get(state, 'learning_rate', filtering=filtering)
+      self.assertEqual(lr, 1.0)
+
+    with self.subTest('Test filtering for specific state'):
+      opt = combine.chain(
+          transform.add_noise(1.0, 0.9, 0), transform.scale_by_adam()
+      )
+      state = opt.init(params)
+
+      filtering = (
+          lambda path, _: isinstance(path[-1], _state_utils.NamedTupleKey)
+          and path[-1].tuple_name == 'ScaleByAdamState'
+      )
+
+      count = _state_utils.tree_get(state, 'count', filtering=filtering)
+      self.assertEqual(count, jnp.asarray(0, dtype=jnp.dtype('int32')))
+
+    with self.subTest('Test extracting a state'):
+      opt = combine.chain(
+          transform.add_noise(1.0, 0.9, 0), transform.scale_by_adam()
+      )
+      state = opt.init(params)
+      noise_state = _state_utils.tree_get(state, 'AddNoiseState')
+      expected_result = (
+          transform.AddNoiseState(
+              count=jnp.asarray(0),
+              rng_key=jnp.array([0, 0], dtype=jnp.dtype('uint32')),
+          )
+      )
+      chex.assert_trees_all_equal(noise_state, expected_result)
+
+  def test_tree_set(self):
+    params = jnp.array([1.0, 2.0, 3.0])
+
+    with self.subTest('Test with flat tree'):
+      tree = ()
+      self.assertRaises(KeyError, _state_utils.tree_set, tree, foo=1.0)
+      tree = jnp.array([1.0, 2.0, 3.0])
+      self.assertRaises(KeyError, _state_utils.tree_set, tree, foo=1.0)
+
+    with self.subTest('Test modifying an injected hyperparam'):
+      opt = _inject.inject_hyperparams(alias.adam)(learning_rate=1.0)
+      state = opt.init(params)
+      new_state = _state_utils.tree_set(state, learning_rate=2.0, b1=3.0)
+      lr = _state_utils.tree_get(new_state, 'learning_rate')
+      self.assertEqual(lr, 2.0)
+
+    with self.subTest('Test modifying an attribute of the state'):
+      opt = _inject.inject_hyperparams(alias.adam)(learning_rate=1.0)
+      state = opt.init(params)
+      new_state = _state_utils.tree_set(state, learning_rate=2.0, b1=3.0)
+      b1 = _state_utils.tree_get(new_state, 'b1')
+      self.assertEqual(b1, 3.0)
+
+    with self.subTest('Test modifying a value not present in the state'):
+      opt = _inject.inject_hyperparams(alias.adam)(learning_rate=1.0)
+      state = opt.init(params)
+      self.assertRaises(KeyError, _state_utils.tree_set, state, ema=2.0)
+
+    with self.subTest('Test jitted tree_set'):
+
+      @jax.jit
+      def set_learning_rate(state, lr):
+        return _state_utils.tree_set(state, learning_rate=lr)
+
+      modified_state = state
+      lr = 1.0
+      for i in range(4):
+        modified_state = set_learning_rate(modified_state, lr / (i + 1))
+        # we simply update state, we don't care about updates.
+        _, modified_state = opt.update(params, modified_state)
+        modified_lr = _state_utils.tree_get(modified_state, 'learning_rate')
+        self.assertEqual(modified_lr, lr / (i + 1))
+
+    with self.subTest('Test modifying several values at once'):
+      opt = combine.chain(
+          alias.adam(learning_rate=1.0), alias.adam(learning_rate=1.0)
+      )
+      state = opt.init(params)
+      new_state = _state_utils.tree_set(state, count=2.0)
+      found_values = _state_utils.tree_get_all_with_path(new_state, 'count')
+      self.assertLen(found_values, 2)
+      for _, value in found_values:
+        self.assertEqual(value, 2.0)
+
+    with self.subTest('Test with optional filtering'):
+      state = dict(hparams=dict(learning_rate=1.0), learning_rate='foo')
+      filtering = lambda _, value: isinstance(value, float)
+      new_state = _state_utils.tree_set(state, filtering, learning_rate=0.5)
+      found_values = _state_utils.tree_get_all_with_path(
+          new_state, 'learning_rate'
+      )
+      expected_result = [
+          ((jtu.DictKey(key='learning_rate'),), 'foo'),
+          ((jtu.DictKey(key='hparams'), jtu.DictKey(key='learning_rate')), 0.5),
+      ]
+      self.assertEqual(found_values, expected_result)
+
+    with self.subTest('Test with nested trees and filtering'):
+      tree = dict(a=dict(a=1.0), b=dict(a=1))
+      filtering = lambda _, value: isinstance(value, float)
+      new_tree = _state_utils.tree_set(tree, filtering, a=2.0)
+      expected_result = dict(a=dict(a=2.0), b=dict(a=1))
+      self.assertEqual(new_tree, expected_result)
+
+    with self.subTest('Test setting a subtree'):
+      tree = dict(a=dict(a=1.0), b=dict(a=1))
+      filtering = lambda _, value: isinstance(value, dict)
+      new_tree = _state_utils.tree_set(tree, filtering, a=dict(c=0.0))
+      expected_result = dict(a=dict(c=0.0), b=dict(a=1))
+      self.assertEqual(new_tree, expected_result)
+
+    with self.subTest('Test setting a specific state'):
+      opt = combine.chain(
+          transform.add_noise(1.0, 0.9, 0), transform.scale_by_adam()
+      )
+      state = opt.init(params)
+
+      filtering = (
+          lambda path, _: isinstance(path[-1], _state_utils.NamedTupleKey)
+          and path[-1].tuple_name == 'ScaleByAdamState'
+      )
+
+      new_state = _state_utils.tree_set(state, filtering, count=jnp.array(42))
+      expected_result = (
+          transform.AddNoiseState(
+              count=jnp.array(0),
+              rng_key=jnp.array([0, 0], dtype=jnp.dtype('uint32')),
+          ),
+          transform.ScaleByAdamState(
+              count=jnp.array(42),
+              mu=jnp.array([0.0, 0.0, 0.0]),
+              nu=jnp.array([0.0, 0.0, 0.0]),
+          ),
+      )
+      chex.assert_trees_all_equal(new_state, expected_result)
+
+    with self.subTest('Test setting a state'):
+      opt = combine.chain(
+          transform.add_noise(1.0, 0.9, 0), transform.scale_by_adam()
+      )
+      state = opt.init(params)
+      new_noise_state = (
+          transform.AddNoiseState(
+              count=jnp.array(42),
+              rng_key=jnp.array([4, 8], dtype=jnp.dtype('uint32')),
+          )
+      )
+      new_state = _state_utils.tree_set(state, AddNoiseState=new_noise_state)
+      expected_result = (
+          transform.AddNoiseState(
+              count=jnp.array(42),
+              rng_key=jnp.array([4, 8], dtype=jnp.dtype('uint32')),
+          ),
+          transform.ScaleByAdamState(
+              count=jnp.array(0),
+              mu=jnp.array([0.0, 0.0, 0.0]),
+              nu=jnp.array([0.0, 0.0, 0.0]),
+          ),
+      )
+      chex.assert_trees_all_equal(new_state, expected_result)
+
+
+def _fake_params():
+  return {
+      'my/fake/module': {
+          'w': jnp.zeros((1, 2)),
+          'b': jnp.zeros((3, 4)),
+      },
+      'my/other/fake/module': {
+          'w': jnp.zeros((1, 2)),
+          'b': jnp.zeros((3, 4)),
+      },
+  }
+
+
+def _fake_param_sharding():
+  return {
+      'my/fake/module': {
+          'w': FakeShardSpec(0),
+          'b': FakeShardSpec(1),
+      },
+      'my/other/fake/module': {
+          'w': FakeShardSpec(2),
+          'b': FakeShardSpec(3),
+      },
+  }
+
+
+if __name__ == '__main__':
+  absltest.main()

testbed/google-deepmind__optax/optax/tree_utils/_tree_math.py

@@ -0,0 +1,318 @@
+# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Utilities to perform maths on pytrees."""
+
+import functools
+import operator
+from typing import Any, Optional, Union
+
+import chex
+import jax
+from jax import tree_util as jtu
+import jax.numpy as jnp
+
+from optax._src import numerics
+
+
+def tree_add(tree_x: Any, tree_y: Any, *other_trees: Any) -> Any:
+  r"""Add two (or more) pytrees.
+
+  Args:
+    tree_x: first pytree.
+    tree_y: second pytree.
+    *other_trees: optional other trees to add
+
+  Returns:
+    the sum of the two (or more) pytrees.
+
+  .. versionchanged:: 0.2.1
+    Added optional ``*other_trees`` argument.
+  """
+  trees = [tree_x, tree_y, *other_trees]
+  return jtu.tree_map(lambda *leaves: sum(leaves), *trees)
+
+
+def tree_sub(tree_x: Any, tree_y: Any) -> Any:
+  r"""Subtract two pytrees.
+
+  Args:
+    tree_x: first pytree.
+    tree_y: second pytree.
+
+  Returns:
+    the difference of the two pytrees.
+  """
+  return jtu.tree_map(operator.sub, tree_x, tree_y)
+
+
+def tree_mul(tree_x: Any, tree_y: Any) -> Any:
+  r"""Multiply two pytrees.
+
+  Args:
+    tree_x: first pytree.
+    tree_y: second pytree.
+
+  Returns:
+    the product of the two pytrees.
+  """
+  return jtu.tree_map(operator.mul, tree_x, tree_y)
+
+
+def tree_div(tree_x: Any, tree_y: Any) -> Any:
+  r"""Divide two pytrees.
+
+  Args:
+    tree_x: first pytree.
+    tree_y: second pytree.
+
+  Returns:
+    the quotient of the two pytrees.
+  """
+  return jtu.tree_map(operator.truediv, tree_x, tree_y)
+
+
+def tree_scalar_mul(
+    scalar: Union[float, jax.Array],
+    tree: Any,
+) -> Any:
+  r"""Multiply a tree by a scalar.
+
+  In infix notation, the function performs ``out = scalar * tree``.
+
+  Args:
+    scalar: scalar value.
+    tree: pytree.
+
+  Returns:
+    a pytree with the same structure as ``tree``.
+  """
+  return jtu.tree_map(lambda x: scalar * x, tree)
+
+
+def tree_add_scalar_mul(
+    tree_x: Any, scalar: Union[float, jax.Array], tree_y: Any
+) -> Any:
+  r"""Add two trees, where the second tree is scaled by a scalar.
+
+  In infix notation, the function performs ``out = tree_x + scalar * tree_y``.
+
+  Args:
+    tree_x: first pytree.
+    scalar: scalar value.
+    tree_y: second pytree.
+
+  Returns:
+    a pytree with the same structure as ``tree_x`` and ``tree_y``.
+  """
+  scalar = jnp.asarray(scalar)
+  return jtu.tree_map(
+      lambda x, y: x + scalar.astype(x.dtype) * y,
+      tree_x,
+      tree_y)
+
+
+_vdot = functools.partial(jnp.vdot, precision=jax.lax.Precision.HIGHEST)
+
+
+def _vdot_safe(a, b):
+  return _vdot(jnp.asarray(a), jnp.asarray(b))
+
+
+def tree_vdot(tree_x: Any, tree_y: Any) -> chex.Numeric:
+  r"""Compute the inner product between two pytrees.
+
+  Examples:
+
+    >>> optax.tree_utils.tree_vdot(
+    ...   {'a': jnp.array([1, 2]), 'b': jnp.array([1, 2])},
+    ...   {'a': jnp.array([-1, -1]), 'b': jnp.array([1, 1])},
+    ... )
+    Array(0, dtype=int32)
+
+  Args:
+    tree_x: first pytree to use.
+    tree_y: second pytree to use.
+
+  Returns:
+    inner product between ``tree_x`` and ``tree_y``, a scalar value.
+
+  Implementation detail: we upcast the values to the highest precision to avoid
+  numerical issues.
+  """
+  vdots = jtu.tree_map(_vdot_safe, tree_x, tree_y)
+  return jtu.tree_reduce(operator.add, vdots)
+
+
+def tree_sum(tree: Any) -> chex.Numeric:
+  """Compute the sum of all the elements in a pytree.
+
+  Args:
+    tree: pytree.
+
+  Returns:
+    a scalar value.
+  """
+  sums = jtu.tree_map(jnp.sum, tree)
+  return jtu.tree_reduce(operator.add, sums)
+
+
+def _square(leaf):
+  return jnp.square(leaf.real) + jnp.square(leaf.imag)
+
+
+def tree_l2_norm(tree: Any, squared: bool = False) -> chex.Numeric:
+  """Compute the l2 norm of a pytree.
+
+  Args:
+    tree: pytree.
+    squared: whether the norm should be returned squared or not.
+
+  Returns:
+    a scalar value.
+  """
+  squared_tree = jtu.tree_map(_square, tree)
+  sqnorm = tree_sum(squared_tree)
+  if squared:
+    return sqnorm
+  else:
+    return jnp.sqrt(sqnorm)
+
+
+def tree_l1_norm(tree: Any) -> chex.Numeric:
+  """Compute the l1 norm of a pytree.
+
+  Args:
+    tree: pytree.
+
+  Returns:
+    a scalar value.
+  """
+  abs_tree = jtu.tree_map(jnp.abs, tree)
+  return tree_sum(abs_tree)
+
+
+def tree_zeros_like(
+    tree: Any,
+    dtype: Optional[jax.typing.DTypeLike] = None,
+) -> Any:
+  """Creates an all-zeros tree with the same structure.
+
+  Args:
+    tree: pytree.
+    dtype: optional dtype to use for the tree of zeros.
+
+  Returns:
+    an all-zeros tree with the same structure as ``tree``.
+  """
+  return jtu.tree_map(lambda x: jnp.zeros_like(x, dtype=dtype), tree)
+
+
+def tree_ones_like(
+    tree: Any,
+    dtype: Optional[jax.typing.DTypeLike] = None,
+) -> Any:
+  """Creates an all-ones tree with the same structure.
+
+  Args:
+    tree: pytree.
+    dtype: optional dtype to use for the tree of ones.
+
+  Returns:
+    an all-ones tree with the same structure as ``tree``.
+  """
+  return jtu.tree_map(lambda x: jnp.ones_like(x, dtype=dtype), tree)
+
+
+def tree_full_like(
+    tree: Any,
+    fill_value: jax.typing.ArrayLike,
+    dtype: Optional[jax.typing.DTypeLike] = None,
+) -> Any:
+  """Creates an identical tree where all tensors are filled with ``fill_value``.
+  
+  Args:
+    tree: pytree.
+    fill_value: the fill value for all tensors in the tree.
+    dtype: optional dtype to use for the tensors in the tree.
+
+  Returns:
+    an tree with the same structure as ``tree``.
+  """
+  return jtu.tree_map(
+      lambda x: jnp.full_like(x, fill_value, dtype=dtype), tree)
+
+
+def tree_clip(
+    tree: Any,
+    min_value: Optional[jax.typing.ArrayLike],
+    max_value: Optional[jax.typing.ArrayLike],
+) -> Any:
+  """Creates an identical tree where all tensors are clipped to `[min, max]`.
+
+  Args:
+    tree: pytree.
+    min_value: min value to clip all tensors to.
+    max_value: max value to clip all tensors to.
+
+  Returns:
+    an tree with the same structure as ``tree``.
+
+  .. versionadded:: 0.2.3
+  """
+  return jtu.tree_map(lambda g: jnp.clip(g, min_value, max_value), tree)
+
+
+def tree_update_moment(updates, moments, decay, order):
+  """Compute the exponential moving average of the `order`-th moment."""
+  return jtu.tree_map(
+      lambda g, t: (1 - decay) * (g ** order) + decay * t, updates, moments)
+
+
+def tree_update_infinity_moment(updates, moments, decay, eps):
+  """Compute the exponential moving average of the infinity norm."""
+  return jtu.tree_map(
+      lambda g, t: jnp.maximum(jnp.abs(g) + eps, decay * t), updates, moments)
+
+
+def tree_update_moment_per_elem_norm(updates, moments, decay, order):
+  """Compute the EMA of the `order`-th moment of the element-wise norm."""
+
+  def orderth_norm(g):
+    if jnp.isrealobj(g):
+      return g ** order
+    else:
+      half_order = order / 2
+      # JAX generates different HLO for int and float `order`
+      if half_order.is_integer():
+        half_order = int(half_order)
+      return numerics.abs_sq(g) ** half_order
+
+  return jtu.tree_map(
+      lambda g, t: (1 - decay) * orderth_norm(g) + decay * t, updates, moments)
+
+
+@functools.partial(jax.jit, inline=True)
+def tree_bias_correction(moment, decay, count):
+  """Performs bias correction. It becomes a no-op as count goes to infinity."""
+  # The conversion to the data type of the moment ensures that bfloat16 remains
+  # bfloat16 in the optimizer state. This conversion has to be done after
+  # `bias_correction_` is calculated as calculating `decay**count` in low
+  # precision can result in it being rounded to 1 and subsequently a
+  # "division by zero" error.
+  bias_correction_ = 1 - decay**count
+
+  # Perform division in the original precision.
+  return jax.tree_util.tree_map(
+      lambda t: t / bias_correction_.astype(t.dtype), moment)