code: def unary_from_labels(labels, n_labels, gt_prob, zero_unsure=True):
      
      assert 0 < gt_prob < 1, "`gt_prob must be in (0,1)."
  
      labels = labels.flatten()
  
      n_energy = -np.log((1.0 - gt_prob) / (n_labels - 1))
      p_energy = -np.log(gt_prob)
  
      # Note that the order of the following operations is important.
      # That's because the later ones overwrite part of the former ones, and only
      # after all of them is `U` correct!
      U = np.full((n_labels, len(labels)), n_energy, dtype='float32')
      U[labels - 1 if zero_unsure else labels, np.arange(U.shape[1])] = p_energy
  
      # Overwrite 0-labels using uniform probability, i.e. "unsure".
      if zero_unsure:
          U[:, labels == 0] = -np.log(1.0 / n_labels)
  
      return U
docs: Simple classifier that is 50% certain that the annotation is correct.
      (same as in the inference example).
  
  
      Parameters
      ----------
      labels: numpy.array
          The label-map, i.e. an array of your data's shape where each unique
          value corresponds to a label.
      n_labels: int
          The total number of labels there are.
          If `zero_unsure` is True (the default), this number should not include
          `0` in counting the labels, since `0` is not a label!
      gt_prob: float
          The certainty of the ground-truth (must be within (0,1)).
      zero_unsure: bool
          If `True`, treat the label value `0` as meaning "could be anything",
          i.e. entries with this value will get uniform unary probability.
          If `False`, do not treat the value `0` specially, but just as any
          other class.