code: def lambda_rank(output, gain, group, name=""):
      r"""
      Groups samples according to ``group``, sorts
      them within each group based on ``output`` and
      computes the Normalized Discounted Cumulative Gain
      (NDCG) at infinity for each group. Concretely,
      the Discounted Cumulative Gain (DCG) at infinity is:
  
      :math:`\mathrm{DCG_{\infty}}()=\sum_{i=0}^{\infty} \frac{gain_{(i)}}{\log(i+2)}`
  
      where :math:`gain_{(i)}` means the gain of the :math:`i`-th ranked sample.
  
      The NDCG is just the DCG  divided by the maximum achievable DCG (obtained
      by placing the samples with the largest gain at the top of the ranking).
  
      Samples in the same group must appear in order of decreasing gain.
  
      It returns 1 minus the average NDCG across all the groups in the minibatch
      multiplied by 100 times the number of samples in the minibatch.
  
      In the backward direction it back-propagates LambdaRank gradients.
  
      Example:
          >>> group = C.input_variable((1,))
          >>> score = C.input_variable((1,), needs_gradient=True)
          >>> gain  = C.input_variable((1,))
          >>> g = np.array([1, 1, 2, 2], dtype=np.float32).reshape(4,1)
          >>> s = np.array([1, 2, 3, 4], dtype=np.float32).reshape(4,1)
          >>> n = np.array([7, 1, 3, 1], dtype=np.float32).reshape(4,1)
          >>> f = C.lambda_rank(score, gain, group)
          >>> np.round(f.grad({score:s, gain:n, group: g}, wrt=[score]),4)
          array([[-0.2121],
          <BLANKLINE>
                 [ 0.2121],
          <BLANKLINE>
                 [-0.1486],
          <BLANKLINE>
                 [ 0.1486]], dtype=float32)
  
      Args:
          output: score of each sample
          gain: gain of each sample
          group: group of each sample
          name (str, optional): the name of the Function instance in the network
      Returns:
          :class:`~cntk.ops.functions.Function`
      """
      from cntk.cntk_py import lambda_rank
  
      dtype = get_data_type(output, gain, group)
      output = sanitize_input(output, dtype)
      gain = sanitize_input(gain, dtype)
      group = sanitize_input(group, dtype)
      return lambda_rank(output, gain, group, name)
  
imports: from __future__ import division
  from __future__ import print_function
  import numpy
  from ..ops.functions import CloneMethod, Function
  from ..variables import Variable, Parameter, Constant
  from cntk.internal import sanitize_input, sanitize_shape, sanitize_axis, sanitize_dynamic_axes, typemap
  from cntk.internal.utils import get_data_type
  from cntk.cntk_py import sentinel_value_for_auto_select_random_seed
  from cntk import times, softmax, parameter
  import cntk
  from ..axis import Axis
label_desc: Use image node_id 7 for calling a global function with example usage: lambda_rank(output, gain, group, name) and returns: lambda_rank