class_docstr: TFTrainer is a simple but feature-complete training and eval loop for TensorFlow, optimized for 🤗 Transformers.
  
  Args:
      model ([`TFPreTrainedModel`]):
          The model to train, evaluate or use for predictions.
      args ([`TFTrainingArguments`]):
          The arguments to tweak training.
      train_dataset ([`~tf.data.Dataset`], *optional*):
          The dataset to use for training. The dataset should yield tuples of `(features, labels)` where `features`
          is a dict of input features and `labels` is the labels. If `labels` is a tensor, the loss is calculated by
          the model by calling `model(features, labels=labels)`. If `labels` is a dict, such as when using a
          QuestionAnswering head model with multiple targets, the loss is instead calculated by calling
          `model(features, **labels)`.
      eval_dataset ([`~tf.data.Dataset`], *optional*):
          The dataset to use for evaluation. The dataset should yield tuples of `(features, labels)` where `features`
          is a dict of input features and `labels` is the labels. If `labels` is a tensor, the loss is calculated by
          the model by calling `model(features, labels=labels)`. If `labels` is a dict, such as when using a
          QuestionAnswering head model with multiple targets, the loss is instead calculated by calling
          `model(features, **labels)`.
      compute_metrics (`Callable[[EvalPrediction], Dict]`, *optional*):
          The function that will be used to compute metrics at evaluation. Must take a [`EvalPrediction`] and return
          a dictionary string to metric values.
      tb_writer (`tf.summary.SummaryWriter`, *optional*):
          Object to write to TensorBoard.
      optimizers (`Tuple[tf.keras.optimizers.Optimizer, tf.keras.optimizers.schedules.LearningRateSchedule]`, *optional*):
          A tuple containing the optimizer and the scheduler to use. The optimizer default to an instance of
          [`tf.keras.optimizers.Adam`] if `args.weight_decay_rate` is 0 else an instance of [`AdamWeightDecay`]. The
          scheduler will default to an instance of [`tf.keras.optimizers.schedules.PolynomialDecay`] if
          `args.num_warmup_steps` is 0 else an instance of [`WarmUp`].
code: def apply_gradients(
      self, features, labels, nb_instances_in_global_batch
  ):
      if self.args.gradient_accumulation_steps == 1:
          gradients = self.training_step(
              features, labels, nb_instances_in_global_batch
          )
  
          self.optimizer.apply_gradients(
              list(zip(gradients, self.model.trainable_variables))
          )
      else:
          for _ in tf.range(self.args.gradient_accumulation_steps):
              reduced_features = {
                  k: ft[
                      : self.args.train_batch_size
                      // self.args.n_replicas
                  ]
                  for k, ft in features.items()
              }
  
              if tf.is_tensor(labels):
                  reduced_labels = labels[
                      : self.args.train_batch_size
                      // self.args.n_replicas
                  ]
              elif isinstance(labels, dict):
                  reduced_labels = {
                      k: lbl[
                          : self.args.train_batch_size
                          // self.args.n_replicas
                      ]
                      for k, lbl in labels.items()
                  }
              else:
                  raise ValueError(
                      "The labels must be either a tf.Tensor or a dict."
                  )
  
              self.training_step(
                  reduced_features,
                  reduced_labels,
                  nb_instances_in_global_batch,
              )
  
              features = {
                  k: tf.concat(
                      [
                          ft[
                              self.args.train_batch_size
                              // self.args.n_replicas :
                          ],
                          reduced_features[k],
                      ],
                      axis=0,
                  )
                  for k, ft in features.items()
              }
  
              if tf.is_tensor(labels):
                  labels = tf.concat(
                      [
                          labels[
                              self.args.train_batch_size
                              // self.args.n_replicas :
                          ],
                          reduced_labels,
                      ],
                      axis=0,
                  )
              elif isinstance(labels, dict):
                  labels = {
                      k: tf.concat(
                          [
                              lbl[
                                  self.args.train_batch_size
                                  // self.args.n_replicas :
                              ],
                              reduced_labels[k],
                          ],
                          axis=0,
                      )
                      for k, lbl in labels.items()
                  }
              else:
                  raise ValueError(
                      "The labels must be either a tf.Tensor or a dict."
                  )
  
          gradients = self.gradient_accumulator.gradients
          gradients = [
              (
                  tf.clip_by_value(
                      grad,
                      -self.args.max_grad_norm,
                      self.args.max_grad_norm,
                  )
              )
              for grad in gradients
          ]
  
          self.optimizer.apply_gradients(
              list(zip(gradients, self.model.trainable_variables))
          )
          self.gradient_accumulator.reset()
  
imports: import datetime
  import math
  import os
  import warnings
  from typing import Callable, Dict, Optional, Tuple
  from .utils import ENV_VARS_TRUE_VALUES
  from .integrations import is_comet_available, is_wandb_available
  import numpy
  import tensorflow
  from tensorflow.python.distribute.values import PerReplica
  from .modeling_tf_utils import TFPreTrainedModel
  from .optimization_tf import GradientAccumulator, create_optimizer
  from .trainer_utils import PREFIX_CHECKPOINT_DIR, EvalPrediction, IntervalStrategy, PredictionOutput, enable_full_determinism, set_seed
  from .training_args_tf import TFTrainingArguments
  from .utils import logging
label_desc: Use image node_id 15 for calling the TFTrainer obj's underlying member method code with example usage: obj.apply_gradients(features, labels, nb_instances_in_global_batch) without return types