code: def lamb_update(
      w: Union[ivy.Array, ivy.NativeArray],
      dcdw: Union[ivy.Array, ivy.NativeArray],
      lr: Union[float, ivy.Array, ivy.NativeArray],
      mw_tm1: Union[ivy.Array, ivy.NativeArray],
      vw_tm1: Union[ivy.Array, ivy.NativeArray],
      step: int,
      /,
      *,
      beta1: float = 0.9,
      beta2: float = 0.999,
      epsilon: float = 1e-7,
      max_trust_ratio: Union[int, float] = 10,
      decay_lambda: float = 0,
      stop_gradients: bool = True,
      out: Optional[ivy.Array] = None,
  ) -> Tuple[ivy.Array, ivy.Array, ivy.Array]:
      """Update weights ws of some function, given the derivatives of some cost c
      with respect to ws, [dc/dw for w in ws], by applying LAMB method.
  
      Parameters
      ----------
      w
          Weights of the function to be updated.
      dcdw
          Derivates of the cost c with respect to the weights ws, [dc/dw for w in ws].
      lr
          Learning rate(s), the rate(s) at which the weights should be updated relative to
          the gradient.
      mw_tm1
          running average of the gradients, from the previous time-step.
      vw_tm1
          running average of second moments of the gradients, from the previous time-step.
      step
          training step.
      beta1
          gradient forgetting factor (Default value = 0.9).
      beta2
          second moment of gradient forgetting factor (Default value = 0.999).
      epsilon
          divisor during adam update, preventing division by zero (Default value = 1e-7).
      max_trust_ratio
          The maximum value for the trust ratio. (Default value = 10)
      decay_lambda
          The factor used for weight decay. (Default value = 0).
      stop_gradients
          Whether to stop the gradients of the variables after each gradient step.
          Default is ``True``.
      out
          optional output array, for writing the new function weights ws_new to. It must
          have a shape that the inputs broadcast to.
  
      Returns
      -------
      ret
          The new function weights ws_new, following the LAMB updates.
  
      Examples
      --------
      With :class:`ivy.Array` inputs:
  
      >>> w = ivy.array([1., 2, 3])
      >>> dcdw = ivy.array([0.5,0.2,0.1])
      >>> lr = ivy.array(0.1)
      >>> vw_tm1 = ivy.zeros(1)
      >>> mw_tm1 = ivy.zeros(3)
      >>> step = ivy.array(1)
      >>> new_weights = ivy.lamb_update(w, dcdw, lr, mw_tm1, vw_tm1, step)
      >>> print(new_weights)
      (ivy.array([0.784, 1.78 , 2.78 ]),
      ... ivy.array([0.05, 0.02, 0.01]),
      ... ivy.array([2.5e-04, 4.0e-05, 1.0e-05]))
  
      >>> w = ivy.array([[1., 2, 3],[4, 6, 1],[1, 0, 7]])
      >>> dcdw = ivy.array([[0.5, 0.2, 0.1],[0.3, 0.6, 0.4],[0.4, 0.7, 0.2]])
      >>> lr = ivy.array(0.1)
      >>> mw_tm1 = ivy.zeros((3,3))
      >>> vw_tm1 = ivy.zeros(3)
      >>> step = ivy.array(1)
      >>> beta1 = 0.9
      >>> beta2 = 0.999
      >>> epsilon = 1e-7
      >>> max_trust_ratio = 10
      >>> decay_lambda = 0
      >>> out = ivy.zeros_like(w)
      >>> stop_gradients = True
      >>> new_weights = ivy.lamb_update(w, dcdw, lr, mw_tm1, vw_tm1, step, beta1=beta1,
      ...                               beta2=beta2, epsilon=epsilon,
      ...                               max_trust_ratio=max_trust_ratio,
      ...                               decay_lambda=decay_lambda, out=out,
      ...                               stop_gradients=stop_gradients)
      >>> print(out)
      ivy.array([[ 0.639,  1.64 ,  2.64 ],
      ...        [ 3.64 ,  5.64 ,  0.639],
      ...        [ 0.639, -0.361,  6.64 ]])
  
      With one :class:`ivy.Container` inputs:
  
      >>> w = ivy.Container(a=ivy.array([1., 2., 3.]), b=ivy.array([4., 5., 6.]))
      >>> dcdw = ivy.array([3., 4., 5.])
      >>> mw_tm1 = ivy.array([0., 0., 0.])
      >>> vw_tm1 = ivy.array([0.])
      >>> lr = ivy.array(1.)
      >>> step = ivy.array([2])
      >>> new_weights = ivy.lamb_update(w, dcdw, mw_tm1, vw_tm1, lr, step)
      >>> print(new_weights)
      ({
          a: ivy.array([1., 2., 3.]),
          b: ivy.array([4., 5., 6.])
      }, ivy.array([0.3, 0.4, 0.5]), ivy.array([1.01, 1.01, 1.02]))
  
      With multiple :class:`ivy.Container` inputs:
  
      >>> w = ivy.Container(a=ivy.array([1.,3.,5.]),
      ...                   b=ivy.array([3.,4.,2.]))
      >>> dcdw = ivy.Container(a=ivy.array([0.2,0.3,0.6]),
      ...                      b=ivy.array([0.6,0.4,0.7]))
      >>> mw_tm1 = ivy.Container(a=ivy.array([0.,0.,0.]),
      ...                        b=ivy.array([0.,0.,0.]))
  
      >>> vw_tm1 = ivy.Container(a=ivy.array([0.,]),
      ...                        b=ivy.array([0.,]))
      >>> step = ivy.array([3.4])
      >>> beta1 = 0.9
      >>> beta2 = 0.999
      >>> epsilon = 1e-7
      >>> max_trust_ratio = 10
      >>> decay_lambda = 0
      >>> stop_gradients = True
      >>> lr = ivy.array(0.5)
      >>> new_weights = ivy.lamb_update(w, dcdw, lr, mw_tm1, vw_tm1, step, beta1=beta1,
      ...                               beta2=beta2, epsilon=epsilon,
      ...                               max_trust_ratio=max_trust_ratio,
      ...                               decay_lambda=decay_lambda,
      ...                               stop_gradients=stop_gradients)
      >>> print(new_weights)
      ({
          a: ivy.array([-0.708, 1.29, 3.29]),
          b: ivy.array([1.45, 2.45, 0.445])
      }, {
          a: ivy.array([0.02, 0.03, 0.06]),
          b: ivy.array([0.06, 0.04, 0.07])
      }, {
          a: ivy.array([4.0e-05, 9.0e-05, 3.6e-04]),
          b: ivy.array([0.00036, 0.00016, 0.00049])
      })
      """
      r1 = ivy.vector_norm(w)
      eff_grads, mw, vw = ivy.adam_step(
          dcdw,
          mw_tm1,
          vw_tm1,
          step,
          beta1=beta1,
          beta2=beta2,
          epsilon=epsilon,
      )
      if decay_lambda > 0:
          r2 = ivy.vector_norm(eff_grads + decay_lambda * w)
      else:
          r2 = ivy.vector_norm(eff_grads)
      r = ivy.minimum(
          ivy.stable_divide(r1, r2), ivy.array(max_trust_ratio)
      )
      lr = r * lr
      return (
          ivy.optimizer_update(
              w, eff_grads, lr, stop_gradients=stop_gradients, out=out
          ),
          mw,
          vw,
      )
  
imports: from typing import Sequence, Union, Optional, Tuple, Callable
  import numpy
  import itertools
  import ivy
  from ivy.utils.backend import current_backend
  from ivy.func_wrapper import handle_array_function, inputs_to_ivy_arrays, to_native_arrays_and_back, handle_out_argument, handle_nestable, handle_array_like_without_promotion, handle_device, handle_backend_invalid
  from ivy.utils.exceptions import handle_exceptions
label_desc: Use image node_id 30 for calling a global function with example usage: lamb_update() and returns: ivy,  mw,  vw