text: import time
  import warnings
  
  import numpy as np
  import matplotlib.pyplot as plt
  
  from sklearn import cluster, datasets, mixture
  from sklearn.preprocessing import StandardScaler
  from itertools import cycle, islice
  
  from pecok import KMeanz
  
  
  np.random.seed(0)
  
  random_state = 170
  n_samples = 500
  blobs = datasets.make_blobs(n_samples=n_samples, random_state=8)
  
  # Anisotropicly distributed data
  # X, y = datasets.make_blobs(n_samples=n_samples, random_state=random_state)
  # transformation = [[0.6, -0.6], [-0.4, 0.8]]
  # X_aniso = np.dot(X, transformation)
  # aniso = (X_aniso, y)
  
  # blobs with varied variances
  varied = datasets.make_blobs(n_samples=n_samples, centers=np.array([[0,0],[1,0]]),
                               cluster_std=[.05, .5],
                               random_state=random_state)
  
  # ============
  # Set up cluster parameters
  # ============
  plt.figure(figsize=(9 * 2 + 3, 12.5))
  plt.subplots_adjust(left=.02, right=.98, bottom=.001, top=.96, wspace=.05,
                      hspace=.01)
  
  plot_num = 1
  
  default_base = {'quantile': .3,
                  'eps': .3,
                  'damping': .9,
                  'preference': -200,
                  'n_neighbors': 10,
                  'n_clusters': 2}
  
  datasets = [
      # (noisy_circles, {'damping': .77, 'preference': -240,
      #                  'quantile': .2, 'n_clusters': 2}),
      # (noisy_moons, {'damping': .75, 'preference': -220, 'n_clusters': 2}),
      (varied, {'eps': .18, 'n_neighbors': 2})]
  
  for i_dataset, (dataset, algo_params) in enumerate(datasets):
      # update parameters with dataset-specific values
      params = default_base.copy()
      params.update(algo_params)
  
      X, y = dataset
      X = StandardScaler().fit_transform(X)
  
      two_means = cluster.MiniBatchKMeans(n_clusters=params['n_clusters'])
      spectral = cluster.SpectralClustering(
          n_clusters=params['n_clusters'], eigen_solver='arpack',
          affinity="nearest_neighbors")
      kmeanz = KMeanz(
          n_clusters=params['n_clusters'], corr=2
      )
      gmm = mixture.GaussianMixture(
          n_components=1, covariance_type='full')
  
      clustering_algorithms = (
          ('MiniBatchKMeans', two_means),
          ('SpectralClustering', spectral),
          ('KMeanz', kmeanz)
          # ('GaussianMixture', gmm)
      )
  
      for name, algorithm in clustering_algorithms:
          t0 = time.time()
  
          # catch warnings related to kneighbors_graph
          with warnings.catch_warnings():
              warnings.filterwarnings(
                  "ignore",
                  message="the number of connected components of the " +
                  "connectivity matrix is [0-9]{1,2}" +
                  " > 1. Completing it to avoid stopping the tree early.",
                  category=UserWarning)
              warnings.filterwarnings(
                  "ignore",
                  message="Graph is not fully connected, spectral embedding" +
                  " may not work as expected.",
                  category=UserWarning)
              algorithm.fit(X)
  
          t1 = time.time()
          if hasattr(algorithm, 'labels_'):
              y_pred = algorithm.labels_.astype(np.int)
          else:
              y_pred = algorithm.predict(X)
  
          plt.subplot(len(datasets), len(clustering_algorithms), plot_num)
          if i_dataset == 0:
              plt.title(name, size=18)
  
          colors = np.array(list(islice(cycle(['#377eb8', '#ff7f00', '#4daf4a',
                                               '#f781bf', '#a65628', '#984ea3',
                                               '#999999', '#e41a1c', '#dede00']),
                                        int(max(y_pred) + 1))))
          plt.scatter(X[:, 0], X[:, 1], s=10, color=colors[y_pred])
  
          plt.xlim(-2.5, 2.5)
          plt.ylim(-2.5, 2.5)
          plt.xticks(())
          plt.yticks(())
          plt.text(.99, .01, ('%.2fs' % (t1 - t0)).lstrip('0'),
                   transform=plt.gca().transAxes, size=15,
                   horizontalalignment='right')
          plot_num += 1
  
  plt.show()
  