code: def averageConvergencePoint(self, prefix, minOverlap, maxOverlap,
                                settlingTime=1, firstStat=0, lastStat=None):
  
      
      convergenceSum = 0.0
      numCorrect = 0.0
      inferenceLength = 1000000
  
      # For each object
      for stats in self.statistics[firstStat:lastStat]:
  
        # For each L2 column locate convergence time
        convergencePoint = 0.0
        for key in stats.iterkeys():
          if prefix in key:
            inferenceLength = len(stats[key])
            columnConvergence = L4L2Experiment._locateConvergencePoint(
              stats[key], minOverlap, maxOverlap)
  
            convergencePoint = max(convergencePoint, columnConvergence)
  
        convergenceSum += ceil(float(convergencePoint) / settlingTime)
  
        if ceil(float(convergencePoint) / settlingTime) <= inferenceLength:
          numCorrect += 1
  
      if len(self.statistics[firstStat:lastStat]) == 0:
        return 10000.0, 0.0
  
      return (convergenceSum / len(self.statistics[firstStat:lastStat]),
              numCorrect / len(self.statistics[firstStat:lastStat]) )
docs: For each object, compute the convergence time - the first point when all
      L2 columns have converged.
  
      Return the average convergence time and accuracy across all objects.
  
      Using inference statistics for a bunch of runs, locate all traces with the
      given prefix. For each trace locate the iteration where it finally settles
      on targetValue. Return the average settling iteration and accuracy across
      all runs.
  
      :param prefix: Use this prefix to filter relevant stats.
      :param minOverlap: Min target overlap
      :param maxOverlap: Max target overlap
      :param settlingTime: Setting time between iteration. Default 1
      :return: Average settling iteration and accuracy across all runs