File size: 3,570 Bytes
09d8e80 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 | # 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)
|