code: def noisy_max(logits, lap_scale, return_clean_votes=False):
      """
      This aggregation mechanism takes the softmax/logit output of several models
      resulting from inference on identical inputs and computes the noisy-max of
      the votes for candidate classes to select a label for each sample: it
      adds Laplacian noise to label counts and returns the most frequent label.
      :param logits: logits or probabilities for each sample
      :param lap_scale: scale of the Laplacian noise to be added to counts
      :param return_clean_votes: if set to True, also returns clean votes (without
                          Laplacian noise). This can be used to perform the
                          privacy analysis of this aggregation mechanism.
      :return: pair of result and (if clean_votes is set to True) the clean counts
               for each class per sample and the original labels produced by
               the teachers.
      """
  
      # Compute labels from logits/probs and reshape array properly
      labels = labels_from_probs(logits)
      labels_shape = np.shape(labels)
      labels = labels.reshape((labels_shape[0], labels_shape[1]))
  
      # Initialize array to hold final labels
      result = np.zeros(int(labels_shape[1]))
  
      if return_clean_votes:
          # Initialize array to hold clean votes for each sample
          clean_votes = np.zeros((int(labels_shape[1]), 10))
  
      # Parse each sample
      for i in xrange(int(labels_shape[1])):
          # Count number of votes assigned to each class
          label_counts = np.bincount(labels[:, i], minlength=10)
  
          if return_clean_votes:
              # Store vote counts for export
              clean_votes[i] = label_counts
  
          # Cast in float32 to prepare before addition of Laplacian noise
          label_counts = np.asarray(label_counts, dtype=np.float32)
  
          # Sample independent Laplacian noise for each class
          for item in xrange(10):
              label_counts[item] += np.random.laplace(
                  loc=0.0, scale=float(lap_scale)
              )
  
          # Result is the most frequent label
          result[i] = np.argmax(label_counts)
  
      # Cast labels to np.int32 for compatibility with deep_cnn.py feed dictionaries
      result = np.asarray(result, dtype=np.int32)
  
      if return_clean_votes:
          # Returns several array, which are later saved:
          # result: labels obtained from the noisy aggregation
          # clean_votes: the number of teacher votes assigned to each sample and class
          # labels: the labels assigned by teachers (before the noisy aggregation)
          return result, clean_votes, labels
      else:
          # Only return labels resulting from noisy aggregation
          return result
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import numpy
  from six.moves import xrange
label_desc: Use image node_id 2 for calling a global function with example usage: noisy_max(logits, lap_scale, return_clean_votes) and returns: result,  clean_votes,  labels, result