class_docstr: Optimizer that implements the FTRL algorithm.
  
  "Follow The Regularized Leader" (FTRL) is an optimization algorithm
  developed at Google for click-through rate prediction in the early 2010s. It
  is most suitable for shallow models with large and sparse feature spaces.
  The algorithm is described by
  [McMahan et al., 2013](https://research.google.com/pubs/archive/41159.pdf).
  The Keras version has support for both online L2 regularization
  (the L2 regularization described in the paper
  above) and shrinkage-type L2 regularization
  (which is the addition of an L2 penalty to the loss function).
  
  Initialization:
  
  ```python
  n = 0
  sigma = 0
  z = 0
  ```
  
  Update rule for one variable `w`:
  
  ```python
  prev_n = n
  n = n + g ** 2
  sigma = (n ** -lr_power - prev_n ** -lr_power) / lr
  z = z + g - sigma * w
  if abs(z) < lambda_1:
    w = 0
  else:
    w = (sgn(z) * lambda_1 - z) / ((beta + sqrt(n)) / alpha + lambda_2)
  ```
  
  Notation:
  
  - `lr` is the learning rate
  - `g` is the gradient for the variable
  - `lambda_1` is the L1 regularization strength
  - `lambda_2` is the L2 regularization strength
  - `lr_power` is the power to scale n.
  
  Check the documentation for the `l2_shrinkage_regularization_strength`
  parameter for more details when shrinkage is enabled, in which case gradient
  is replaced with a gradient with shrinkage.
  
  Args:
      learning_rate: A float, a
          `keras.optimizers.schedules.LearningRateSchedule` instance, or
          a callable that takes no arguments and returns the actual value to
          use. The learning rate. Defaults to `0.001`.
      learning_rate_power: A float value, must be less or equal to zero.
          Controls how the learning rate decreases during training. Use zero
          for a fixed learning rate.
      initial_accumulator_value: The starting value for accumulators. Only
          zero or positive values are allowed.
      l1_regularization_strength: A float value, must be greater than or equal
          to zero. Defaults to `0.0`.
      l2_regularization_strength: A float value, must be greater than or equal
          to zero. Defaults to `0.0`.
      l2_shrinkage_regularization_strength: A float value, must be greater
          than or equal to zero. This differs from L2 above in that the L2
          above is a stabilization penalty, whereas this L2 shrinkage is a
          magnitude penalty. When input is sparse shrinkage will only happen
          on the active weights.
      beta: A float value, representing the beta value from the paper.
          Defaults to `0.0`.
      {{base_optimizer_keyword_args}}
docstr: Initialize optimizer variables.
  
  Args:
      var_list: list of model variables to build Ftrl variables on.
docstr_tok: ["Initialize","optimizer","variables",".","Args",":","var_list",":","list","of","model","variables","to","build","Ftrl","variables","on","."]
code: def build(self, var_list):
      """Initialize optimizer variables.
  
      Args:
          var_list: list of model variables to build Ftrl variables on.
      """
      if self.built:
          return
      super().build(var_list)
      self._accumulators = []
      self._linears = []
      for var in var_list:
          self._accumulators.append(
              self.add_variable(
                  shape=var.shape,
                  dtype=var.dtype,
                  name="accumulator",
                  initializer=initializers.Constant(
                      self.initial_accumulator_value,
                  ),
              )
          )
          self._linears.append(
              self.add_variable_from_reference(
                  reference_variable=var, name="linear"
              )
          )
  
file_path: keras/keras/optimizers/ftrl.py
imports: from keras import initializers
  from keras import ops
  from keras.api_export import keras_export
  from keras.optimizers import optimizer
label_desc: Use image node_id 2 for calling the Ftrl obj's underlying member method code with example usage: obj.build(var_list) without return types