code: def __init__(
      self,
      learning_rate,
      weight_decay=None,
      clipnorm=None,
      clipvalue=None,
      global_clipnorm=None,
      use_ema=False,
      ema_momentum=0.99,
      ema_overwrite_frequency=None,
      loss_scale_factor=None,
      gradient_accumulation_steps=None,
      name=None,
      **kwargs,
  ):
      self._lock = False
  
      if kwargs.pop("decay", None) is not None:
          warnings.warn(
              "Argument `decay` is no longer supported and will be ignored."
          )
      if kwargs:
          raise ValueError(f"Argument(s) not recognized: {kwargs}")
  
      if name is None:
          name = auto_name(self.__class__.__name__)
      self.name = name
      self.weight_decay = weight_decay
      self.clipnorm = clipnorm
      self.global_clipnorm = global_clipnorm
      self.clipvalue = clipvalue
      self.use_ema = use_ema
      self.loss_scale_factor = loss_scale_factor
      self.gradient_accumulation_steps = gradient_accumulation_steps
  
      if gradient_accumulation_steps:
          if not gradient_accumulation_steps >= 2:
              raise ValueError(
                  "`gradient_accumulation_steps` must be an integer >= 2. "
                  "Received: gradient_accumulation_steps="
                  f"{gradient_accumulation_steps}"
              )
  
      if use_ema:
          # Verify the arguments related to EMA.
          if ema_momentum > 1 or ema_momentum < 0:
              raise ValueError(
                  "`ema_momentum` must be in the range [0, 1]. "
                  f"Received: ema_momentum={ema_momentum}"
              )
          if ema_overwrite_frequency and (
              not isinstance(ema_overwrite_frequency, int)
              or ema_overwrite_frequency < 1
          ):
              raise ValueError(
                  "`ema_overwrite_frequency` must be an integer >= 1 or "
                  "None. Received: ema_overwrite_frequency="
                  f"{ema_overwrite_frequency}"
              )
      self.ema_momentum = ema_momentum
      self.ema_overwrite_frequency = ema_overwrite_frequency
  
      if self.clipnorm is not None and self.global_clipnorm is not None:
          raise ValueError(
              "Only one of `clipnorm` and `global_clipnorm` can "
              f"be set. Received: clipnorm={self.clipnorm}, "
              f"global_clipnorm={self.global_clipnorm}"
          )
      self.built = False
  
      # Set up variable tracking.
      self._variables = []
      self._trainable_variables = []
      self._tracker = tracking.Tracker(
          {
              "variables": (
                  lambda x: isinstance(x, backend.Variable),
                  self._variables,
              ),
          }
      )
      self._trainable_variables_indices = {}
  
      # Create iteration variable
      # Note: dtype="int" will resolve to int32 in JAX
      # (since int64 is disallowed in JAX) and to int64 in TF.
      with backend.name_scope(self.name, caller=self):
          iterations = backend.Variable(
              0, name="iteration", dtype="int", trainable=False
          )
      self._track_variable(iterations)
      self.iterations = iterations
  
      # Create learning rate (schedule or variable)
      if isinstance(
          learning_rate, learning_rate_schedule.LearningRateSchedule
      ):
          self._learning_rate = learning_rate
      elif callable(learning_rate):
          self._learning_rate = learning_rate
      else:
          if not isinstance(learning_rate, float):
              raise ValueError(
                  "Argument `learning_rate` should be float, or an instance "
                  "of LearningRateSchedule, or a callable "
                  "(that takes in the current iteration value "
                  "and returns the corresponding learning rate value). "
                  f"Received instead: learning_rate={learning_rate}"
              )
          with backend.name_scope(self.name, caller=self):
              learning_rate = backend.Variable(
                  learning_rate,
                  name="learning_rate",
                  dtype=backend.floatx(),
                  trainable=False,
              )
          self._track_variable(learning_rate)
          self._learning_rate = learning_rate
  
imports: import re
  import warnings
  import numpy
  from keras import backend
  from keras import initializers
  from keras import ops
  from keras.optimizers.schedules import learning_rate_schedule
  from keras.saving import serialization_lib
  from keras.utils import tracking
  from keras.utils.naming import auto_name
label_desc: Use image node_id 1 to create a new BaseOptimizer object  with example: obj = BaseOptimizer(learning_rate, weight_decay, clipnorm, clipvalue, global_clipnorm, use_ema, ema_momentum, ema_overwrite_frequency, loss_scale_factor, gradient_accumulation_steps, name)