class_docstr: A LearningRateSchedule that uses an delayed cosine decay schedule.
code: def __call__(self, step):
      with tf.ops.name_scope_v2(
          self.name or "WarmupDelayedCosineDecay"
      ) as name:
          constant_learning_rate = (
              tf.ops.convert_to_tensor_v2_with_dispatch(
                  self.constant_learning_rate
              )
          )
          dtype = constant_learning_rate.dtype
          initial_learning_rate = tf.cast(
              self.initial_learning_rate, dtype
          )
          end_learning_rate = tf.cast(self.end_learning_rate, dtype)
  
          def cosine_decay(s, a, b, c, d):
              """Applies cosine decay to given step s.
  
              Args:
                s: The current step.
                a: The step when to start decay.
                b: The number of decay steps.
                c: The learning rate before the decay.
                d: The learning rate after the decay.
  
              Returns:
                Decay function applied to given step.
              """
              return (
                  tf.cos((s - a) * math.pi / b) * (c - d) / 2.0
                  + (d + c) / 2.0
              )
  
          def warmup_phase():
              return cosine_decay(
                  tf.cast(step, dtype),
                  0,
                  tf.cast(self.warmup_steps, dtype),
                  initial_learning_rate,
                  constant_learning_rate,
              )
  
          def constant_phase():
              return constant_learning_rate
  
          def decay_phase():
              return cosine_decay(
                  tf.cast(step, dtype),
                  tf.cast(self.start_decay_step, dtype),
                  tf.cast(self.decay_steps, dtype),
                  constant_learning_rate,
                  end_learning_rate,
              )
  
          def end_phase():
              return end_learning_rate
  
          return tf.control_flow_ops.case(
              [
                  (step < self.warmup_steps, warmup_phase),
                  (step < self.start_decay_step, constant_phase),
                  (
                      step < self.start_decay_step + self.decay_steps,
                      decay_phase,
                  ),
              ],
              default=end_phase,
              exclusive=False,
              name=name,
          )
  
file_path: graphics/tensorflow_graphics/projects/points_to_3Dobjects/losses/learning_rate_schedule.py
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import math
  import tensorflow
label_desc: Use image node_id 2 for calling the WarmupDelayedCosineDecay obj's underlying member method code with example usage: obj.__call__(step) and returns: tf, unknown, cosine_decay, constant_learning_rate, cosine_decay, end_learning_rate