def _resource_apply_dense(self, grad, var, apply_state=None):             )             s = top_singular_vector -        var_update_tensor = tf.math.multiply(var, lr) - (1 - lr) * lambda_ * s-        var_update_kwargs = {-            "resource": var.handle,-            "value": var_update_tensor,-        }-        var_update_op = tf.raw_ops.AssignVariableOp(**var_update_kwargs)-        return tf.group(var_update_op)+        return var.assign(+            var * lr - (1 - lr) * lambda_ * s, use_locking=self._use_locking

+# Copyright 2020 The TensorFlow Authors. 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.+# ==============================================================================+"""Proximal Adagrad optimizer."""++import tensorflow as tf++from tensorflow_addons.utils.types import FloatTensorLike++from typing import Union, Callable+from typeguard import typechecked++[email protected]_keras_serializable(package="Addons")+class ProximalAdagrad(tf.keras.optimizers.Optimizer):+    """Optimizer that implements the Proximal Adagrad algorithm.++    References:+        - [Efficient Learning using Forward-Backward Splitting](+          http://papers.nips.cc/paper/3793-efficient-learning-using-forward-backward-splitting.pdf).+    """++    @typechecked+    def __init__(+        self,+        learning_rate: Union[FloatTensorLike, Callable] = 0.001,+        initial_accumulator_value: float = 0.1,+        l1_regularization_strength: float = 0.0,+        l2_regularization_strength: float = 0.0,+        name: str = "ProximalAdagrad",+        **kwargs+    ):+        """Construct a new Proximal Adagrad optimizer.++        Args:+            learning_rate: A Tensor or a floating point value, or a schedule+                that is a `tf.keras.optimizers.schedules.LearningRateSchedule`.+                The learning rate.+            initial_accumulator_value: A floating point value.+                Starting value for the accumulators, must be positive.+            l1_regularization_strength: A floating point value.+                The l1 regularization term, must be greater than or+                equal to zero.+            l2_regularization_strength: A floating point value.+                The l2 regularization term, must be greater than or+                equal to zero.+            name: Optional name for the operations created when applying+                gradients. Defaults to "ProximalAdagrad".+            **kwargs: keyword arguments. Allowed to be {`clipnorm`,+                `clipvalue`, `lr`, `decay`}. `clipnorm` is clip gradients+                by norm; `clipvalue` is clip gradients by value, `decay` is+                included for backward compatibility to allow time inverse+                decay of learning rate. `lr` is included for backward+                compatibility, recommended to use `learning_rate` instead.+        Raises:+            ValueError: If the `initial_accumulator_value`,+                `l1_regularization_strength` or `l2_regularization_strength`+                is invalid.+        """+        if initial_accumulator_value < 0.0:+            raise ValueError("`initial_accumulator_value` must be non-negative.")+        if l1_regularization_strength < 0.0:+            raise ValueError("`l1_regularization_strength` must be non-negative.")+        if l2_regularization_strength < 0.0:+            raise ValueError("`l2_regularization_strength` must be non-negative.")+        super().__init__(name, **kwargs)+        self._set_hyper("learning_rate", kwargs.get("lr", learning_rate))+        self.l1_regularization_strength = l1_regularization_strength+        self.l2_regularization_strength = l2_regularization_strength

+# Copyright 2020 The TensorFlow Authors. 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.+# ==============================================================================+"""Proximal Adagrad optimizer."""++import tensorflow as tf++from tensorflow_addons.utils.types import FloatTensorLike++from typing import Union, Callable+from typeguard import typechecked++[email protected]_keras_serializable(package="Addons")+class ProximalAdagrad(tf.keras.optimizers.Optimizer):+    """Optimizer that implements the Proximal Adagrad algorithm.++    References:+        - [Efficient Learning using Forward-Backward Splitting](+          http://papers.nips.cc/paper/3793-efficient-learning-using-forward-backward-splitting.pdf).+    """++    @typechecked+    def __init__(+        self,+        learning_rate: Union[FloatTensorLike, Callable] = 0.001,+        initial_accumulator_value: float = 0.1,+        l1_regularization_strength: float = 0.0,+        l2_regularization_strength: float = 0.0,+        name: str = "ProximalAdagrad",+        **kwargs+    ):+        """Construct a new Proximal Adagrad optimizer.++        Args:+            learning_rate: A Tensor or a floating point value, or a schedule+                that is a `tf.keras.optimizers.schedules.LearningRateSchedule`.+                The learning rate.+            initial_accumulator_value: A floating point value.+                Starting value for the accumulators, must be positive.+            l1_regularization_strength: A floating point value.+                The l1 regularization term, must be greater than or+                equal to zero.+            l2_regularization_strength: A floating point value.+                The l2 regularization term, must be greater than or+                equal to zero.+            name: Optional name for the operations created when applying+                gradients. Defaults to "ProximalAdagrad".+            **kwargs: keyword arguments. Allowed to be {`clipnorm`,+                `clipvalue`, `lr`, `decay`}. `clipnorm` is clip gradients+                by norm; `clipvalue` is clip gradients by value, `decay` is+                included for backward compatibility to allow time inverse+                decay of learning rate. `lr` is included for backward+                compatibility, recommended to use `learning_rate` instead.+        Raises:+            ValueError: If the `initial_accumulator_value`,+                `l1_regularization_strength` or `l2_regularization_strength`+                is invalid.+        """+        if initial_accumulator_value < 0.0:+            raise ValueError("`initial_accumulator_value` must be non-negative.")+        if l1_regularization_strength < 0.0:+            raise ValueError("`l1_regularization_strength` must be non-negative.")+        if l2_regularization_strength < 0.0:+            raise ValueError("`l2_regularization_strength` must be non-negative.")+        super().__init__(name, **kwargs)+        self._set_hyper("learning_rate", kwargs.get("lr", learning_rate))+        self.l1_regularization_strength = l1_regularization_strength+        self.l2_regularization_strength = l2_regularization_strength

+# Copyright 2020 The TensorFlow Authors. 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.+# ==============================================================================+"""Proximal Adagrad optimizer."""++import tensorflow as tf

+# Copyright 2020 The TensorFlow Authors. 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.+# ==============================================================================+"""Proximal Adagrad optimizer."""++import tensorflow as tf++from tensorflow_addons.utils.types import FloatTensorLike++from typing import Union, Callable+from typeguard import typechecked++[email protected]_keras_serializable(package="Addons")+class ProximalAdagrad(tf.keras.optimizers.Optimizer):+    """Optimizer that implements the Proximal Adagrad algorithm.++    References:+        - [Efficient Learning using Forward-Backward Splitting](+          http://papers.nips.cc/paper/3793-efficient-learning-using-forward-backward-splitting.pdf).+    """++    @typechecked+    def __init__(+        self,+        learning_rate: Union[FloatTensorLike, Callable] = 0.001,+        initial_accumulator_value: float = 0.1,+        l1_regularization_strength: float = 0.0,+        l2_regularization_strength: float = 0.0,+        name: str = "ProximalAdagrad",+        **kwargs+    ):+        """Construct a new Proximal Adagrad optimizer.++        Args:+            learning_rate: A Tensor or a floating point value, or a schedule+                that is a `tf.keras.optimizers.schedules.LearningRateSchedule`.+                The learning rate.+            initial_accumulator_value: A floating point value.+                Starting value for the accumulators, must be positive.+            l1_regularization_strength: A floating point value.+                The l1 regularization term, must be greater than or+                equal to zero.+            l2_regularization_strength: A floating point value.+                The l2 regularization term, must be greater than or+                equal to zero.+            name: Optional name for the operations created when applying+                gradients. Defaults to "ProximalAdagrad".+            **kwargs: keyword arguments. Allowed to be {`clipnorm`,+                `clipvalue`, `lr`, `decay`}. `clipnorm` is clip gradients+                by norm; `clipvalue` is clip gradients by value, `decay` is+                included for backward compatibility to allow time inverse+                decay of learning rate. `lr` is included for backward+                compatibility, recommended to use `learning_rate` instead.+        Raises:+            ValueError: If the `initial_accumulator_value`,+                `l1_regularization_strength` or `l2_regularization_strength`+                is invalid.+        """+        if initial_accumulator_value < 0.0:+            raise ValueError("`initial_accumulator_value` must be non-negative.")+        if l1_regularization_strength < 0.0:+            raise ValueError("`l1_regularization_strength` must be non-negative.")+        if l2_regularization_strength < 0.0:+            raise ValueError("`l2_regularization_strength` must be non-negative.")+        super().__init__(name, **kwargs)+        self._set_hyper("learning_rate", kwargs.get("lr", learning_rate))+        self.l1_regularization_strength = l1_regularization_strength+        self.l2_regularization_strength = l2_regularization_strength