code: def learning_parameter_schedule(
      schedule, minibatch_size=None, epoch_size=None
  ):
      """
      Create a learning parameter schedule.
  
      Args:
          schedule (float or list): if float, is the parameter schedule to be used
           for all samples. In case of list [p_1, p_2, .., p_n], the i-th parameter p_i in the list is used as the
           value from the (``epoch_size`` * (i-1) + 1)-th sample to the (``epoch_size`` * i)-th sample. If list contains
           pair, i.e. [(num_epoch_1, p_1), (num_epoch_n, p_2), .., (num_epoch_n, p_n)], the i-th parameter is used as a
           value from the (``epoch_size`` * (num_epoch_0 + ... + num_epoch_2 + ... + num_epoch_(i-1) + 1)-th sample to the
           (``epoch_size`` * num_epoch_i)-th sample (taking num_epoch_0 = 0 as a special initialization).
          minibatch_size (int): an integer to specify the minibatch size that schedule are designed for.
           CNTK will scale the schedule internally so as to simulate the behavior of the schedule as much as possible
           to match the designed effect. If it is not specified, CNTK will set to the special value :attr:`IGNORE`.
          epoch_size (optional, int): number of samples as a scheduling unit.
           Parameters in the schedule change their values every ``epoch_size``
           samples. If no ``epoch_size`` is provided, this parameter is substituted
           by the size of the full data sweep, in which case the scheduling unit is
           the entire data sweep (as indicated by the MinibatchSource) and parameters
           change their values on the sweep-by-sweep basis specified by the
           ``schedule``.
  
      Returns:
          learning parameter schedule
      """
      if isinstance(
          schedule, cntk_py.training_double_parameter_schedule
      ):
          return schedule
  
      is_minibatch_size_explicitly_specified = True
      if minibatch_size == None:
          is_minibatch_size_explicitly_specified = False
          minibatch_size = 0
  
      if isinstance(schedule, (int, float)):
          if epoch_size is not None:
              warnings.warn(
                  "When providing the schedule as a number, epoch_size is ignored",
                  RuntimeWarning,
              )
          schedule = cntk_py.training_double_parameter_schedule(
              *[schedule, minibatch_size]
          )
          schedule.is_minibatch_size_explicitly_specified = (
              is_minibatch_size_explicitly_specified
          )
          return schedule
  
      epoch_size = (
          epoch_size
          if epoch_size is not None
          else cntk_py.training_double_parameter_schedule.full_data_sweep
      )
      if isinstance(schedule, list):
          schedule = _prepare_training_parameter_list(schedule)
          args = [schedule, epoch_size, minibatch_size]
          schedule = cntk_py.training_double_parameter_schedule(*args)
          schedule.is_minibatch_size_explicitly_specified = (
              is_minibatch_size_explicitly_specified
          )
          return schedule
  
      raise ValueError(
          "schedule must be either a float or a list, not %s"
          % type(schedule)
      )
  
imports: from enum import Enum, unique
  import warnings
  import numpy
  import cntk.internal.utils
  from ..None import cntk_py, NDArrayView, asarray
  from cntk.internal import typemap
  from ..internal.swig_helper import map_if_possible
label_desc: Use image node_id 7 for calling a global function with example usage: learning_parameter_schedule(schedule, minibatch_size, epoch_size) and returns: schedule, schedule, schedule