code: def make_blobs(
      n_samples=100,
      n_features=2,
      centers=3,
      cluster_std=1.0,
      center_box=(-10.0, 10.0),
      shuffle=True,
      random_state=None,
  ):
      """Generate isotropic Gaussian blobs for clustering.
  
      Read more in the :ref:`User Guide <sample_generators>`.
  
      Parameters
      ----------
      n_samples : int, optional (default=100)
          The total number of points equally divided among clusters.
  
      n_features : int, optional (default=2)
          The number of features for each sample.
  
      centers : int or array of shape [n_centers, n_features], optional
          (default=3)
          The number of centers to generate, or the fixed center locations.
  
      cluster_std : float or sequence of floats, optional (default=1.0)
          The standard deviation of the clusters.
  
      center_box : pair of floats (min, max), optional (default=(-10.0, 10.0))
          The bounding box for each cluster center when centers are
          generated at random.
  
      shuffle : boolean, optional (default=True)
          Shuffle the samples.
  
      random_state : int, RandomState instance or None, optional (default=None)
          If int, random_state is the seed used by the random number generator;
          If RandomState instance, random_state is the random number generator;
          If None, the random number generator is the RandomState instance used
          by `np.random`.
  
      Returns
      -------
      X : array of shape [n_samples, n_features]
          The generated samples.
  
      y : array of shape [n_samples]
          The integer labels for cluster membership of each sample.
  
      Examples
      --------
      >>> from sklearn.datasets.samples_generator import make_blobs
      >>> X, y = make_blobs(n_samples=10, centers=3, n_features=2,
      ...                   random_state=0)
      >>> print(X.shape)
      (10, 2)
      >>> y
      array([0, 0, 1, 0, 2, 2, 2, 1, 1, 0])
  
      See also
      --------
      make_classification: a more intricate variant
      """
      generator = check_random_state(random_state)
  
      if isinstance(centers, numbers.Integral):
          centers = generator.uniform(
              center_box[0], center_box[1], size=(centers, n_features)
          )
      else:
          centers = check_array(centers)
          n_features = centers.shape[1]
  
      if isinstance(cluster_std, numbers.Real):
          cluster_std = np.ones(len(centers)) * cluster_std
  
      X = []
      y = []
  
      n_centers = centers.shape[0]
      n_samples_per_center = [int(n_samples // n_centers)] * n_centers
  
      for i in range(n_samples % n_centers):
          n_samples_per_center[i] += 1
  
      for i, (n, std) in enumerate(
          zip(n_samples_per_center, cluster_std)
      ):
          X.append(
              centers[i]
              + generator.normal(scale=std, size=(n, n_features))
          )
          y += [i] * n
  
      X = np.concatenate(X)
      y = np.array(y)
  
      if shuffle:
          indices = np.arange(n_samples)
          generator.shuffle(indices)
          X = X[indices]
          y = y[indices]
  
      return X, y
  
imports: import numbers
  import array
  import numpy
  from scipy import linalg
  import scipy.sparse
  from ..preprocessing import MultiLabelBinarizer
  from ..utils import check_array, check_random_state
  from ..utils import shuffle
  from ..utils.fixes import astype
  from ..utils.random import sample_without_replacement
  from ..externals import six
label_desc: Use image node_id 8 for calling a global function with example usage: make_blobs(n_samples, n_features, centers, cluster_std, center_box, shuffle, random_state) and returns: X,  y