code: import torch.nn.functional as F
  import torch
  
  
  def CondorOrdinalCrossEntropy(logits, levels, importance_weights=None, reduction='mean'):
      """Computes the CONDOR loss described in
  
      CONDOR TBD.
  
      Parameters
      ----------
      logits : torch.tensor, shape(num_examples, num_classes-1)
          Outputs of the CONDOR layer.
  
      levels : torch.tensor, shape(num_examples, num_classes-1)
          True labels represented as extended binary vectors
          (via `condor_pytorch.dataset.levels_from_labelbatch`).
  
      importance_weights : torch.tensor, shape=(num_classes-1,) (default=None)
          Optional weights for the different labels in levels.
          A tensor of ones, i.e.,
          `torch.ones(num_classes-1, dtype=torch.float32)`
          will result in uniform weights that have the same effect as None.
  
      reduction : str or None (default='mean')
          If 'mean' or 'sum', returns the averaged or summed loss value across
          all data points (rows) in logits. If None, returns a vector of
          shape (num_examples,)
  
      Returns
      ----------
          loss : torch.tensor
          A torch.tensor containing a single loss value (if `reduction='mean'` or '`sum'`)
          or a loss value for each data record (if `reduction=None`).
  
      Examples
      ----------
      >>> import torch
      >>> levels = torch.tensor(
      ...    [[1., 1., 0., 0.],
      ...     [1., 0., 0., 0.],
      ...    [1., 1., 1., 1.]])
      >>> logits = torch.tensor(
      ...    [[2.1, 1.8, -2.1, -1.8],
      ...     [1.9, -1., -1.5, -1.3],
      ...     [1.9, 1.8, 1.7, 1.6]])
      >>> CondorOrdinalCrossEntropy(logits, levels)
      tensor(0.8259)
      """
  
      if not logits.shape == levels.shape:
          raise ValueError("Please ensure that logits (%s) has the same shape as levels (%s). "
                           % (logits.shape, levels.shape))
  
      logprobs = torch.cumsum(F.logsigmoid(logits), dim = 1)
      term1 = (logprobs*levels
               + torch.log(1 - torch.exp(logprobs)+torch.finfo(torch.float32).eps)*(1-levels))
  
      if importance_weights is not None:
          term1 *= importance_weights
  
      val = (-torch.sum(term1, dim=1))
  
      if reduction == 'mean':
          loss = torch.mean(val)
      elif reduction == 'sum':
          loss = torch.sum(val)
      elif reduction is None:
          loss = val
      else:
          s = ('Invalid value for `reduction`. Should be "mean", '
               '"sum", or None. Got %s' % reduction)
          raise ValueError(s)
  
      return loss
  
apis: torch.sum torch.nn.functional.logsigmoid torch.exp torch.finfo torch.mean