docs: def feature_burstness(corpus, featureset_name, feature, k=5, normalize=True,
                        s=1.1, gamma=1., **slice_kwargs):
      """
      Estimate burstness profile for a feature over the ``'date'`` axis.
  
      Parameters
      ----------
      corpus : :class:`.Corpus`
      feature : str
          Name of featureset in ``corpus``. E.g. ``'citations'``.
      findex : int
          Index of ``feature`` in ``corpus``.
      k : int
          (default: 5) Number of burst states.
      normalize : bool
          (default: True) If True, burstness is expressed relative to the hightest
          possible state (``k-1``). Otherwise, states themselves are returned.
      kwargs : kwargs
          Parameters for burstness automaton HMM.
      """
  
  
      if featureset_name not in corpus.features:
          corpus.index_feature(featureset_name)
  
      if 'date' not in corpus.indices:
          corpus.index('date')
  
      # Get time-intervals between occurrences.
      dates = [min(corpus.indices['date'].keys()) - 1]    # Pad start.
      X_ = [1.]
  
      years, values = corpus.feature_distribution(featureset_name, feature)
      for year, N in izip(years, values):
          if N == 0:
              continue
  
          if N > 1:
              if year == dates[-1] + 1:
                  for n in xrange(int(N)):
                      X_.append(1./N)
                      dates.append(year)
              else:
                  X_.append(float(year - dates[-1]))
                  dates.append(year)
                  for n in xrange(int(N) - 1):
                      X_.append(1./(N - 1))
                      dates.append(year)
          else:
              X_.append(float(year - dates[-1]))
              dates.append(year)
  
      # Get optimum state sequence.
      st = _forward(map(lambda x: x*100, X_), s=s, gamma=gamma, k=k)
  
      # Bin by date.
      A = defaultdict(list)
      for i in xrange(len(X_)):
          A[dates[i]].append(st[i])
  
      # Normalize.
      if normalize:
          A = {key: mean(values)/k for key, values in A.items()}
      else:
          A = {key: mean(values) for key, values in A.items()}
  
      D = sorted(A.keys())
      return D[1:], [A[d] for d in D[1:]]