text: import numpy as np
  
  def softmax_func(y):
      """Computes softmax activations.
        This function performs the equivalent of
            softmax = tf.exp(logits) / tf.reduce_sum(tf.exp(logits))
      another form: np.exp(y)/np.sum(np.exp(y),axis=1,keepdims=True)
      """
  
      b = y - np.max(y, axis=1, keepdims=True)
      expb = np.exp(b)
      softmax = expb / np.sum(expb, axis=1, keepdims=True)
      return softmax
  
  
  def confusion_matrix_at_thresholds(labels, predictions, thresholds,includes=None):
      """Computes true_positives, false_negatives, true_negatives, false_positives.
        Args:
          labels: A np.array whose shape matches `predictions`. Will be cast to
            `bool`.
          predictions: A floating point np.array of arbitrary shape and whose values
            are in the range `[0, 1]`.
          thresholds: A python list or tuple of float thresholds in `[0, 1]`.
          includes: Tuple of keys to return, from 'tp', 'fn', 'tn', fp'. If `None`,
              default to all four.
        Returns:
          values: Dict of variables of shape `[len(thresholds)]`. Keys are from
              `includes`.
        """
      all_includes = ('tp', 'fn', 'tn', 'fp')
      if includes is None:
          includes = all_includes
      else:
          for include in includes:
              if include not in all_includes:
                  raise ValueError('Invaild key: %s.' % include)
      # Reshape predictions and labels.
      #This function is often used in dichotomies.
      #In multi-classification problems, we often stretch the dimensions directly into dichotomies.
      predictions_2d = np.reshape(predictions, [-1, 1])
      labels_2d = np.reshape(labels.astype(dtype=np.bool), [1, -1])
      num_predictions = predictions_2d.shape[0]
      num_thresholds = len(thresholds)
      #thresh_tiled's shape:[num_thresholds,num_predictions]
      thresh_tiled = np.tile(
          np.expand_dims(np.array(thresholds),axis=1),[1,num_predictions])
      pred_is_pos = np.greater(
          np.tile(np.transpose(predictions_2d), [num_thresholds, 1]),
          thresh_tiled)
      if ('fn' in includes) or ('tn' in includes):
          pred_is_neg = np.logical_not(pred_is_pos)
      # Tile labels by number of thresholds
      #label_is_pos's shape:[num_thresholds,num_predictions]
      label_is_pos = np.tile(labels_2d, [num_thresholds, 1])
      if ('fp' in includes) or ('tn' in includes):
          label_is_neg = np.logical_not(label_is_pos)
  
      values = {}
      if 'tp' in includes:
          is_true_positive =np.logical_and(label_is_pos, pred_is_pos).astype(np.float32)
          values['tp'] = np.sum(is_true_positive,axis=1)
      if 'fn' in includes:
          is_false_negative = np.logical_and(label_is_pos, pred_is_neg).astype(np.float32)
          values['fn'] = np.sum(is_false_negative,axis=1)
      if 'tn' in includes:
          is_true_negative = np.logical_and(label_is_neg, pred_is_neg).astype(np.float32)
          values['tn'] = np.sum(is_true_negative, axis=1)
      if 'fp' in includes:
          is_false_positive = np.logical_and(label_is_neg, pred_is_pos).astype(np.float32)
          values['fp'] = np.sum(is_false_positive,axis=1)
      return values
  
  def roc_pr_curve(values,curve='ROC'):
      """Computes the roc-auc or pr-auc based on confusion counts.
      Args:
          values: A dict from the func:confusion_matrix_at_thresholds and must have
              four keys:tp,fp,fn,tn
          curve: Specifies the name of the curve to be computed, 'ROC' [default] or
          'PR' for the Precision-Recall-curve.
      Returns:
          x_axis: A python list of the curve's x-axis. In ROC it's fpr;In PR it's Recall.
          y_axis:A python list of the curve's y-axis. In ROC it's tpr;In PR it's Precision.
              fpr=fp/(fp+tn)
              tpr=tp/(tp+fn)
              Recall=tpr
              Precision=tp/(tp+fp)
      """
      if 'tp' not in values.keys():
          raise ValueError('values must have the key tp')
      if 'fp' not in values.keys():
          raise ValueError('values must have the key fp')
      if 'fn' not in values.keys():
          raise ValueError('values must have the key fn')
      if 'tn' not in values.keys():
          raise ValueError('values must have the key tn')
      tp = values['tp']
      fp = values['fp']
      fn = values['fn']
      tn = values['tn']
      # Add epsilons to avoid dividing by 0.
      epsilon = 1.0e-6
      rec = np.divide(tp + epsilon, tp + fn + epsilon)
      if curve == 'ROC':
          fp_rate = np.divide(fp+ epsilon, fp + tn + epsilon)
          x_axis = fp_rate
          y_axis = rec
      else:  # curve == 'PR'.
          prec = np.divide(tp + epsilon, tp + fp + epsilon)
          x_axis = rec
          y_axis = prec
      return x_axis, y_axis
  
  def auc(labels, predictions, num_thresholds=200,
          curve='ROC'):
      """Computes the approximate AUC via a Riemann sum.
        We get four variables `true_positives`,`true_negatives`, `false_positives`
        and `false_negatives` that are used to compute the AUC first.
        And then compute auc_curve using the function roc_pr_curve.
        The `num_thresholds` variable controls the degree of discretization with
        larger numbers of thresholds more closely approximating the true AUC.
        For best results, `predictions` should be distributed approximately uniformly
        in the range [0, 1] and not peaked around 0 or 1.
        Args:
          labels: A np.array whose shape matches `predictions`. Will be cast to
            `bool`.
          predictions: A floating point np.array of arbitrary shape and whose values
            are in the range `[0, 1]`.
          num_thresholds: The number of thresholds to use when discretizing the roc
            curve.
          curve: Specifies the name of the curve to be computed, 'ROC' [default] or
          'PR' for the Precision-Recall-curve.
        Returns:
          auc: A scalar representing the current area-under-curve.
        """
      kepsilon = 1e-7  # to account for floating point imprecisions
      thresholds = [(i + 1) * 1.0 / (num_thresholds - 1)
                    for i in range(num_thresholds - 2)]
      thresholds = [0.0 - kepsilon] + thresholds + [1.0 + kepsilon]
      values=confusion_matrix_at_thresholds(labels,predictions,thresholds)
      x_axis, y_axis = roc_pr_curve(values,curve=curve)
      auc_value=np.sum(np.multiply(
          x_axis[:num_thresholds - 1] - x_axis[1:],
              (y_axis[:num_thresholds - 1] + y_axis[1:]) / 2.))
      return auc_value
  
  def accuracy(labels, predictions):
      """Calculates the degree of `predictions` matches `labels`.
      Args:
          labels: A np.array whose shape matches `predictions`.
          predictions: A floating point np.array of arbitrary shape and it's the
          predicted value.
      returns:
          accuracy: A  accuracy, the value of `total` divided by `count`.
      """
      acc_val = np.equal(
          np.argmax(labels, 1),
          np.argmax(predictions, 1)).astype(np.float)
      accuracy=np.mean(acc_val)
      return accuracy
  def confusion_matrix_one_hot(labels, predictions):
      """Computes true_positives, false_negatives, true_negatives, false_positives.
  
        Args:
          labels: A np.array whose shape matches `predictions` and must be one_hot.
           Will be cast to `bool`.
          predictions: A floating point np.array of arbitrary shape.
        Returns:
          values: Dict of variables of shape `[predictions.shape[1]]`.
        example:
          labels:[[1,0,0]
                  [0,1,0]
                  [0,0,1]]
          predictions:
                 [[9.1,5.0,7.8]   true
                  [0.3,0.7,1.4]   false
                  [4.3,1.3,5.3]]  true
          returns:
          values{'tp':[1,0,1]
                 'tn':[2,2,1]
                 'fp':[0,0,1]
                 'fn':[0,1,0]
                 }
      """
      #transpose prediction to one hot.for the example above,it will be:
      #[[1,0,0]
      # [0,0,1]
      # [0,0,1]]
      prediction_one_hot=np.eye(predictions.shape[1])[np.argmax(predictions,axis=1)]
      values = {}
      is_true_positive = np.logical_and(
          np.equal(labels, True), np.equal(prediction_one_hot, True))
      is_false_positive = np.logical_and(
          np.equal(labels, False), np.equal(prediction_one_hot, True))
      is_true_negatives = np.logical_and(
          np.equal(labels, False), np.equal(prediction_one_hot, False))
      is_false_negatives = np.logical_and(
          np.equal(labels, True), np.equal(prediction_one_hot, False))
      values['tp']=np.sum(
          is_true_positive.astype(dtype=np.float32),axis=0)
      values['fp']=np.sum(
          is_false_positive.astype(dtype=np.float32),axis=0)
      values['tn']=np.sum(
          is_true_negatives.astype(dtype=np.float32),axis=0)
      values['fn']=np.sum(
          is_false_negatives.astype(dtype=np.float32),axis=0)
      return values
  
  def precision_score_one_hot(labels, predictions,average=None):
      """compute precision score, precision=tp/(tp+fp)
      the labels must be one_hot.
      the predictions is prediction results.
      Args:
          labels: A np.array whose shape matches `predictions` and must be one_hot.
      Will be cast to `bool`.
          predictions: A floating point np.array of arbitrary shape.
          average : string, [None(default), 'micro', 'macro',]
              This parameter is required for multiclass/multilabel targets.
              If ``None``, the scores for each class are returned. Otherwise, this
              determines the type of averaging performed on the data:
              ``'micro'``:
                  Calculate metrics globally by counting the total true positives,
                  false negatives and false positives.
              ``'macro'``:
                  Calculate metrics for each label, and find their unweighted
                  mean.  This does not take label imbalance into account.
  
      Returns:
          values:  A score  .
  
      References
      -----------------------
       [1]   https://blog.csdn.net/sinat_28576553/article/details/80258619
      """
      # Add epsilons to avoid dividing by 0.
      epsilon = 1.0e-6
      values=confusion_matrix_one_hot(labels,predictions)
      if average is None:
          tp= values['tp']
          fp= values['fp']
          p=np.divide(tp+epsilon, tp + fp+epsilon)
          #p=np.where(
          #      np.greater(tp + fp, 0), np.divide(tp+epsilon, tp + fp+epsilon),0)
          return p
      elif average=='micro':
          tp=np.sum(values['tp'])
          fp=np.sum(values['fp'])
          return np.divide(tp+epsilon, tp + fp+epsilon)
  
      elif average=='macro':
          tp= values['tp']
          fp= values['fp']
          p=np.divide(tp+epsilon, tp + fp+epsilon)
          return np.average(p)
      else:
          raise ValueError('Invaild average: %s.' % average)
  
  def recall_score_one_hot(labels,predictions,average=None):
      """compute recall score, precision=tp/(tp+fn)
      the labels must be one_hot.
      the predictions is prediction results.
      Args:
          labels: A np.array whose shape matches `predictions` and must be one_hot.
      Will be cast to `bool`.
          predictions: A floating point np.array of arbitrary shape.
              average : string, [None(default), 'micro', 'macro',]
              This parameter is required for multiclass/multilabel targets.
              If ``None``, the scores for each class are returned. Otherwise, this
              determines the type of averaging performed on the data:
              ``'micro'``:
                  Calculate metrics globally by counting the total true positives,
                  false negatives and false positives.
              ``'macro'``:
                  Calculate metrics for each label, and find their unweighted
                  mean.  This does not take label imbalance into account.
      Returns:
          values:  A score  .
  
      References
      -----------------------
       [1]   https://blog.csdn.net/sinat_28576553/article/details/80258619
      """
      # Add epsilons to avoid dividing by 0.
      epsilon = 1.0e-6
      values=confusion_matrix_one_hot(labels,predictions)
      if average is None:
          tp= values['tp']
          fn= values['fn']
          p=np.divide(tp+epsilon, tp + fn+epsilon)
          return p
      elif average=='micro':
          tp=np.sum(values['tp'])
          fn=np.sum(values['fn'])
          return   np.divide(tp+epsilon, tp + fn+epsilon)
  
      elif average=='macro':
          tp= values['tp']
          fn= values['fn']
          p=np.divide(tp+epsilon, tp + fn+epsilon)
          return np.average(p)
      else:
          raise ValueError('Invaild average: %s.' % average)
  def f_score_one_hot(labels,predictions,beta=1.0,average=None):
      """compute f score, =(1+beta*beta)precision*recall/(beta*beta*precision+recall)
       the labels must be one_hot.
       the predictions is prediction results.
       Args:
           labels: A np.array whose shape matches `predictions` and must be one_hot.
       Will be cast to `bool`.
           predictions: A floating point np.array of arbitrary shape.
               average : string, [None(default), 'micro', 'macro',]
               This parameter is required for multiclass/multilabel targets.
               If ``None``, the scores for each class are returned. Otherwise, this
               determines the type of averaging performed on the data:
               ``'micro'``:
                   Calculate metrics globally by counting the total true positives,
                   false negatives and false positives.
               ``'macro'``:
                   Calculate metrics for each label, and find their unweighted
                   mean.  This does not take label imbalance into account.
       Returns:
           values:  A score float.
  
       References
       -----------------------
        [1]   https://blog.csdn.net/sinat_28576553/article/details/80258619
       """
      if beta < 0:
          raise ValueError("beta should be >=0 in the F-beta score")
      beta2 = beta ** 2
      p=precision_score_one_hot(labels,predictions,average=average)
      r=recall_score_one_hot(labels,predictions,average=average)
      #In the functions:precision and recall,add a epsilon,so p and r will
      #not be zero.
      f=(1+beta2)*p*r/(beta2*p+r)
      if average is None or average=='micro':
          p = precision_score_one_hot(labels, predictions, average=average)
          r = recall_score_one_hot(labels, predictions, average=average)
          f = (1 + beta2) * p * r / (beta2 * p + r)
          return f
      elif average=='macro':
          p = precision_score_one_hot(labels, predictions, average=None)
          r = recall_score_one_hot(labels, predictions, average=None)
          f = (1 + beta2) * p * r / (beta2 * p + r)
          return np.average(f)
      else:
          raise ValueError('Invaild average: %s.' % average)
  
  
  '''
  if __name__=="__main__":
  
      #label_list=np.array([[0,1],[1,0],[0,1]],dtype=np.float32)
      # prediction_list=np.array([[0.2,5.8],[0.6,0.4],[0.7,0.3]],dtype=np.float32)
      label_list = np.array([[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0], [0, 1, 0], [0, 1, 0], [0, 1, 0], [0, 0, 1], [0, 0, 1]])
      prediction_list = np.array([[1, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1], [0, 1, 0], [0, 1, 0], [0, 0, 1], [0, 1, 0],
                    [0, 0, 1]])  # ,dtype=np.float32)
  
      #prediction_list=softmax_func(prediction_list)
      #auc_x=auc(label_list,prediction_list)
      #print(auc_x)
      mm=np.argmax(prediction_list,axis=1)#[1 0 0]
      xx=np.eye(prediction_list.shape[1])[mm]
  
      #mm=math_ops.equal(prediction_tensor,True)
  
      #predictions=math_ops.cast(prediction_tensor, dtype=dtypes.bool)
  
      is_true_positive = np.logical_and(
          np.equal(label_list, True), np.equal(xx, True))
  
      ##values=np.sum(values,axis=0)
  
      label_list = np.array([[1, 0, 0],  [0, 1, 0],  [0, 0, 1]])
      prediction_list = np.array([[1, 0, 0], [1, 0, 0],  [0, 0, 1]])  # ,dtype=np.float32)
      values=confusion_matrix_one_hot(label_list,prediction_list)
      print(values)
      p1=precision_score_one_hot(label_list,prediction_list,average=None)
      p2=precision_score_one_hot(label_list,prediction_list,average='macro')
      p3=precision_score_one_hot(label_list,prediction_list,average='micro')
      r1=recall_score_one_hot(label_list,prediction_list,average=None)
      r2=recall_score_one_hot(label_list,prediction_list,average='macro')
      r3=recall_score_one_hot(label_list,prediction_list,average='micro')
      x1=f_score_one_hot(label_list,prediction_list,average=None)
      x2=f_score_one_hot(label_list,prediction_list,average='macro')
      x3=f_score_one_hot(label_list,prediction_list,average='micro')
  
      print(p1,p2,p3)
      print(r1,r2,r3)
      print(x1,x2,x3)
  '''
  