class_docstr: Gaussian Mixture Model.
  
  Representation of a Gaussian mixture model probability distribution.
  This class allows for easy evaluation of, sampling from, and
  maximum-likelihood estimation of the parameters of a GMM distribution.
  
  Initializes parameters such that every mixture component has zero
  mean and identity covariance.
  
  Read more in the :ref:`User Guide <gmm>`.
  
  Parameters
  ----------
  n_components : int, optional
      Number of mixture components. Defaults to 1.
  
  covariance_type : string, optional
      String describing the type of covariance parameters to
      use.  Must be one of 'spherical', 'tied', 'diag', 'full'.
      Defaults to 'diag'.
  
  random_state: RandomState or an int seed (None by default)
      A random number generator instance
  
  min_covar : float, optional
      Floor on the diagonal of the covariance matrix to prevent
      overfitting. Defaults to 1e-3.
  
  tol : float, optional
      Convergence threshold. EM iterations will stop when average
      gain in log-likelihood is below this threshold. Defaults to 1e-3.
  
  n_iter : int, optional
      Number of EM iterations to perform.
  
  n_init : int, optional
      Number of initializations to perform. The best results is kept.
  
  params : string, optional
      Controls which parameters are updated in the training
      process.  Can contain any combination of 'w' for weights,
      'm' for means, and 'c' for covars. Defaults to 'wmc'.
  
  init_params : string, optional
      Controls which parameters are updated in the initialization
      process.  Can contain any combination of 'w' for weights,
      'm' for means, and 'c' for covars. Defaults to 'wmc'.
  
  verbose : int, default: 0
      Enable verbose output. If 1 then it always prints the current
      initialization and iteration step. If greater than 1 then
      it prints additionally the change and time needed for each step.
  
  Attributes
  ----------
  weights_ : array, shape (`n_components`,)
      This attribute stores the mixing weights for each mixture component.
  
  means_ : array, shape (`n_components`, `n_features`)
      Mean parameters for each mixture component.
  
  covars_ : array
      Covariance parameters for each mixture component.  The shape
      depends on `covariance_type`::
  
          (n_components, n_features)             if 'spherical',
          (n_features, n_features)               if 'tied',
          (n_components, n_features)             if 'diag',
          (n_components, n_features, n_features) if 'full'
  
  converged_ : bool
      True when convergence was reached in fit(), False otherwise.
  
  See Also
  --------
  
  DPGMM : Infinite gaussian mixture model, using the Dirichlet
      process, fit with a variational algorithm
  
  
  VBGMM : Finite gaussian mixture model fit with a variational
      algorithm, better for situations where there might be too little
      data to get a good estimate of the covariance matrix.
  
  Examples
  --------
  
  >>> import numpy as np
  >>> from sklearn import mixture
  >>> np.random.seed(1)
  >>> g = mixture.GMM(n_components=2)
  >>> # Generate random observations with two modes centered on 0
  >>> # and 10 to use for training.
  >>> obs = np.concatenate((np.random.randn(100, 1),
  ...                       10 + np.random.randn(300, 1)))
  >>> g.fit(obs)  # doctest: +NORMALIZE_WHITESPACE
  GMM(covariance_type='diag', init_params='wmc', min_covar=0.001,
          n_components=2, n_init=1, n_iter=100, params='wmc',
          random_state=None, tol=0.001, verbose=0)
  >>> np.round(g.weights_, 2)
  array([ 0.75,  0.25])
  >>> np.round(g.means_, 2)
  array([[ 10.05],
         [  0.06]])
  >>> np.round(g.covars_, 2) # doctest: +SKIP
  array([[[ 1.02]],
         [[ 0.96]]])
  >>> g.predict([[0], [2], [9], [10]]) # doctest: +ELLIPSIS
  array([1, 1, 0, 0]...)
  >>> np.round(g.score([[0], [2], [9], [10]]), 2)
  array([-2.19, -4.58, -1.75, -1.21])
  >>> # Refit the model on new data (initial parameters remain the
  >>> # same), this time with an even split between the two modes.
  >>> g.fit(20 * [[0]] + 20 * [[10]])  # doctest: +NORMALIZE_WHITESPACE
  GMM(covariance_type='diag', init_params='wmc', min_covar=0.001,
          n_components=2, n_init=1, n_iter=100, params='wmc',
          random_state=None, tol=0.001, verbose=0)
  >>> np.round(g.weights_, 2)
  array([ 0.5,  0.5])
docstr: Estimate model parameters with the EM algorithm.
  
  A initialization step is performed before entering the
  expectation-maximization (EM) algorithm. If you want to avoid
  this step, set the keyword argument init_params to the empty
  string '' when creating the GMM object. Likewise, if you would
  like just to do an initialization, set n_iter=0.
  
  Parameters
  ----------
  X : array_like, shape (n, n_features)
      List of n_features-dimensional data points. Each row
      corresponds to a single data point.
  
  Returns
  -------
  responsibilities : array, shape (n_samples, n_components)
      Posterior probabilities of each mixture component for each
      observation.
docstr_tok: ["Estimate","model","parameters","with","the","EM","algorithm",".","A","initialization","step","is","performed","before","entering","the","expectation-maximization","(","EM",")","algorithm",".","If","you","want","to","avoid","this","step",",","set","the","keyword","argument","init_params","to","the","empty","string","``","when","creating","the","GMM","object",".","Likewise",",","if","you","would","like","just","to","do","an","initialization",",","set","n_iter=0",".","Parameters","--","--","--","--","--","X",":","array_like",",","shape","(","n",",","n_features",")","List","of","n_features-dimensional","data","points",".","Each","row","corresponds","to","a","single","data","point",".","Returns","--","--","--","-","responsibilities",":","array",",","shape","(","n_samples",",","n_components",")","Posterior","probabilities","of","each","mixture","component","for","each","observation","."]
code: def _fit(self, X, y=None, do_prediction=False):
      """Estimate model parameters with the EM algorithm.
  
      A initialization step is performed before entering the
      expectation-maximization (EM) algorithm. If you want to avoid
      this step, set the keyword argument init_params to the empty
      string '' when creating the GMM object. Likewise, if you would
      like just to do an initialization, set n_iter=0.
  
      Parameters
      ----------
      X : array_like, shape (n, n_features)
          List of n_features-dimensional data points. Each row
          corresponds to a single data point.
  
      Returns
      -------
      responsibilities : array, shape (n_samples, n_components)
          Posterior probabilities of each mixture component for each
          observation.
      """
  
      # initialization step
      X = check_array(
          X, dtype=np.float64, ensure_min_samples=2, estimator=self
      )
      if X.shape[0] < self.n_components:
          raise ValueError(
              "GMM estimation with %s components, but got only %s samples"
              % (self.n_components, X.shape[0])
          )
  
      max_log_prob = -np.infty
  
      if self.verbose > 0:
          print("Expectation-maximization algorithm started.")
  
      for init in range(self.n_init):
          if self.verbose > 0:
              print("Initialization " + str(init + 1))
              start_init_time = time()
  
          if "m" in self.init_params or not hasattr(self, "means_"):
              self.means_ = (
                  cluster.KMeans(
                      n_clusters=self.n_components,
                      random_state=self.random_state,
                  )
                  .fit(X)
                  .cluster_centers_
              )
              if self.verbose > 1:
                  print("\tMeans have been initialized.")
  
          if "w" in self.init_params or not hasattr(self, "weights_"):
              self.weights_ = np.tile(
                  1.0 / self.n_components, self.n_components
              )
              if self.verbose > 1:
                  print("\tWeights have been initialized.")
  
          if "c" in self.init_params or not hasattr(self, "covars_"):
              cv = np.cov(X.T) + self.min_covar * np.eye(X.shape[1])
              if not cv.shape:
                  cv.shape = (1, 1)
              self.covars_ = (
                  distribute_covar_matrix_to_match_covariance_type(
                      cv, self.covariance_type, self.n_components
                  )
              )
              if self.verbose > 1:
                  print("\tCovariance matrices have been initialized.")
  
          # EM algorithms
          current_log_likelihood = None
          # reset self.converged_ to False
          self.converged_ = False
  
          for i in range(self.n_iter):
              if self.verbose > 0:
                  print("\tEM iteration " + str(i + 1))
                  start_iter_time = time()
              prev_log_likelihood = current_log_likelihood
              # Expectation step
              log_likelihoods, responsibilities = self.score_samples(X)
              current_log_likelihood = log_likelihoods.mean()
  
              # Check for convergence.
              if prev_log_likelihood is not None:
                  change = abs(
                      current_log_likelihood - prev_log_likelihood
                  )
                  if self.verbose > 1:
                      print("\t\tChange: " + str(change))
                  if change < self.tol:
                      self.converged_ = True
                      if self.verbose > 0:
                          print("\t\tEM algorithm converged.")
                      break
  
              # Maximization step
              self._do_mstep(
                  X, responsibilities, self.params, self.min_covar
              )
              if self.verbose > 1:
                  print(
                      "\t\tEM iteration "
                      + str(i + 1)
                      + " took {0:.5f}s".format(
                          time() - start_iter_time
                      )
                  )
  
          # if the results are better, keep it
          if self.n_iter:
              if current_log_likelihood > max_log_prob:
                  max_log_prob = current_log_likelihood
                  best_params = {
                      "weights": self.weights_,
                      "means": self.means_,
                      "covars": self.covars_,
                  }
                  if self.verbose > 1:
                      print("\tBetter parameters were found.")
  
          if self.verbose > 1:
              print(
                  "\tInitialization "
                  + str(init + 1)
                  + " took {0:.5f}s".format(time() - start_init_time)
              )
  
      # check the existence of an init param that was not subject to
      # likelihood computation issue.
      if np.isneginf(max_log_prob) and self.n_iter:
          raise RuntimeError(
              "EM algorithm was never able to compute a valid likelihood "
              + "given initial parameters. Try different init parameters "
              + "(or increasing n_init) or check for degenerate data."
          )
  
      if self.n_iter:
          self.covars_ = best_params["covars"]
          self.means_ = best_params["means"]
          self.weights_ = best_params["weights"]
      else:  # self.n_iter == 0 occurs when using GMM within HMM
          # Need to make sure that there are responsibilities to output
          # Output zeros because it was just a quick initialization
          responsibilities = np.zeros((X.shape[0], self.n_components))
  
      return responsibilities
  
imports: import numpy
  from scipy import linalg
  from time import time
  from ..base import BaseEstimator
  from ..utils import check_random_state, check_array, deprecated
  from ..utils.extmath import logsumexp
  from ..utils.validation import check_is_fitted
  from ..None import cluster
  from sklearn.externals.six.moves import zip
label_desc: Use image node_id 10 for calling the _GMMBase obj's underlying member method code with example usage: obj._fit(X, y, do_prediction) and returns: responsibilities