docs: def clustered_sortind(x, k=10, scorefunc=None):
      """
      Uses MiniBatch k-means clustering to cluster matrix into groups.
  
      Each cluster of rows is then sorted by `scorefunc` -- by default, the max
      peak height when all rows in a cluster are averaged, or
      cluster.mean(axis=0).max().
  
      Returns the index that will sort the rows of `x` and a list of "breaks".
      `breaks` is essentially a cumulative row count for each cluster boundary.
      In other words, after plotting the array you can use axhline on each
      "break" to plot the cluster boundary.
  
      If `k` is a list or tuple, iteratively try each one and select the best
      with the lowest mean distance from cluster centers.
  
      :param x: Matrix whose rows are to be clustered
      :param k: Number of clusters to create or a list of potential clusters; the
          optimum will be chosen from the list
      :param scorefunc: Optional function for sorting rows within clusters.  Must
          accept a single argument of a NumPy array.
      """
      try:
          from sklearn.cluster import MiniBatchKMeans
      except ImportError:
          raise ImportError('please install scikits.learn for '
                            'clustering.')
  
      # If integer, do it once and we're done
      if isinstance(k, int):
          best_k = k
  
      else:
          mean_dists = {}
          for _k in k:
              mbk = MiniBatchKMeans(init='k-means++', n_clusters=_k)
              mbk.fit(x)
              mean_dists[_k] = mbk.transform(x).mean()
          best_k = sorted(mean_dists.items(), key=lambda x: x[1])[-1][0]
  
      mbk = MiniBatchKMeans(init='k-means++', n_clusters=best_k)
      mbk.fit(x)
      k = best_k
      labels = mbk.labels_
      scores = np.zeros(labels.shape, dtype=float)
  
      if not scorefunc:
          def scorefunc(x):
              return x.mean(axis=0).max()
  
      for label in range(k):
          ind = labels == label
          score = scorefunc(x[ind, :])
          scores[ind] = score
  
      pos = 0
      breaks = []
      ind = np.argsort(scores)
      for k, g in itertools.groupby(labels[ind]):
          pos += len(list(g))
          breaks.append(pos)
  
      return ind, breaks