text: """Benchmarks of Lasso regularization path computation using Lars and CD
  
  The input data is mostly low rank but is a fat infinite tail.
  """
  from collections import defaultdict
  import gc
  import sys
  from time import time
  
  import numpy as np
  
  from sklearn.linear_model import lars_path, lars_path_gram
  from sklearn.linear_model import lasso_path
  from sklearn.datasets import make_regression
  
  
  def compute_bench(samples_range, features_range):
  
      it = 0
  
      results = defaultdict(lambda: [])
  
      max_it = len(samples_range) * len(features_range)
      for n_samples in samples_range:
          for n_features in features_range:
              it += 1
              print('====================')
              print('Iteration %03d of %03d' % (it, max_it))
              print('====================')
              dataset_kwargs = {
                  'n_samples': n_samples,
                  'n_features': n_features,
                  'n_informative': n_features // 10,
                  'effective_rank': min(n_samples, n_features) / 10,
                  #'effective_rank': None,
                  'bias': 0.0,
              }
              print("n_samples: %d" % n_samples)
              print("n_features: %d" % n_features)
              X, y = make_regression(**dataset_kwargs)
  
              gc.collect()
              print("benchmarking lars_path (with Gram):", end='')
              sys.stdout.flush()
              tstart = time()
              G = np.dot(X.T, X)  # precomputed Gram matrix
              Xy = np.dot(X.T, y)
              lars_path_gram(Xy=Xy, Gram=G, n_samples=y.size, method='lasso')
              delta = time() - tstart
              print("%0.3fs" % delta)
              results['lars_path (with Gram)'].append(delta)
  
              gc.collect()
              print("benchmarking lars_path (without Gram):", end='')
              sys.stdout.flush()
              tstart = time()
              lars_path(X, y, method='lasso')
              delta = time() - tstart
              print("%0.3fs" % delta)
              results['lars_path (without Gram)'].append(delta)
  
              gc.collect()
              print("benchmarking lasso_path (with Gram):", end='')
              sys.stdout.flush()
              tstart = time()
              lasso_path(X, y, precompute=True)
              delta = time() - tstart
              print("%0.3fs" % delta)
              results['lasso_path (with Gram)'].append(delta)
  
              gc.collect()
              print("benchmarking lasso_path (without Gram):", end='')
              sys.stdout.flush()
              tstart = time()
              lasso_path(X, y, precompute=False)
              delta = time() - tstart
              print("%0.3fs" % delta)
              results['lasso_path (without Gram)'].append(delta)
  
      return results
  
  
  if __name__ == '__main__':
      from mpl_toolkits.mplot3d import axes3d  # register the 3d projection
      import matplotlib.pyplot as plt
  
      samples_range = np.linspace(10, 1460, 3).astype(int) 
      features_range = np.linspace(10, 1460 , 3).astype(int) 
      results = compute_bench(samples_range, features_range)
  
      max_time = max(max(t) for t in results.values())
  
      fig = plt.figure('scikit-learn Lasso path benchmark results')
      i = 1
      for c, (label, timings) in zip('bcry', sorted(results.items())):
          ax = fig.add_subplot(2, 2, i, projection='3d')
          X, Y = np.meshgrid(samples_range, features_range)
          Z = np.asarray(timings).reshape(samples_range.shape[0],
                                          features_range.shape[0])
  
          # plot the actual surface
          ax.plot_surface(X, Y, Z.T, cstride=1, rstride=1, color=c, alpha=0.8)
  
          # dummy point plot to stick the legend to since surface plot do not
          # support legends (yet?)
          # ax.plot([1], [1], [1], color=c, label=label)
  
          ax.set_xlabel('n_samples')
          ax.set_ylabel('n_features')
          ax.set_zlabel('Time (s)')
          ax.set_zlim3d(0.0, max_time * 1.1)
          ax.set_title(label)
          # ax.legend()
          i += 1
      #plt.show()
  