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: Return the number of free parameters in the model.
docstr_tok: ["Return","the","number","of","free","parameters","in","the","model","."]
code: def _n_parameters(self):
      """Return the number of free parameters in the model."""
      ndim = self.means_.shape[1]
      if self.covariance_type == "full":
          cov_params = self.n_components * ndim * (ndim + 1) / 2.0
      elif self.covariance_type == "diag":
          cov_params = self.n_components * ndim
      elif self.covariance_type == "tied":
          cov_params = ndim * (ndim + 1) / 2.0
      elif self.covariance_type == "spherical":
          cov_params = self.n_components
      mean_params = ndim * self.n_components
      return int(cov_params + mean_params + self.n_components - 1)
  
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 13 for calling the _GMMBase obj's underlying member method code with example usage: obj._n_parameters() and returns: int