class_docstr: Variational Inference for the Infinite Gaussian Mixture Model.
  
  DPGMM stands for Dirichlet Process Gaussian Mixture Model, and it
  is an infinite mixture model with the Dirichlet Process as a prior
  distribution on the number of clusters. In practice the
  approximate inference algorithm uses a truncated distribution with
  a fixed maximum number of components, but almost always the number
  of components actually used depends on the data.
  
  Stick-breaking Representation of a Gaussian mixture model
  probability distribution. This class allows for easy and efficient
  inference of an approximate posterior distribution over the
  parameters of a Gaussian mixture model with a variable number of
  components (smaller than the truncation parameter n_components).
  
  Initialization is with normally-distributed means and identity
  covariance, for proper convergence.
  
  Read more in the :ref:`User Guide <dpgmm>`.
  
  Parameters
  ----------
  n_components: int, default 1
      Number of mixture components.
  
  covariance_type: string, default 'diag'
      String describing the type of covariance parameters to
      use.  Must be one of 'spherical', 'tied', 'diag', 'full'.
  
  alpha: float, default 1
      Real number representing the concentration parameter of
      the dirichlet process. Intuitively, the Dirichlet Process
      is as likely to start a new cluster for a point as it is
      to add that point to a cluster with alpha elements. A
      higher alpha means more clusters, as the expected number
      of clusters is ``alpha*log(N)``.
  
  tol : float, default 1e-3
      Convergence threshold.
  
  n_iter : int, default 10
      Maximum number of iterations to perform before convergence.
  
  params : string, default 'wmc'
      Controls which parameters are updated in the training
      process.  Can contain any combination of 'w' for weights,
      'm' for means, and 'c' for covars.
  
  init_params : string, default 'wmc'
      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
      Controls output verbosity.
  
  Attributes
  ----------
  covariance_type : string
      String describing the type of covariance parameters used by
      the DP-GMM.  Must be one of 'spherical', 'tied', 'diag', 'full'.
  
  n_components : int
      Number of mixture components.
  
  weights_ : array, shape (`n_components`,)
      Mixing weights for each mixture component.
  
  means_ : array, shape (`n_components`, `n_features`)
      Mean parameters for each mixture component.
  
  precs_ : array
      Precision (inverse 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
  --------
  GMM : Finite Gaussian mixture model fit with EM
  
  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.
docstr: Maximize the variational lower bound
  
  Update each of the parameters to maximize the lower bound.
docstr_tok: ["Maximize","the","variational","lower","bound","Update","each","of","the","parameters","to","maximize","the","lower","bound","."]
code: def _do_mstep(self, X, z, params):
      """Maximize the variational lower bound
  
      Update each of the parameters to maximize the lower bound."""
      self._monitor(X, z, "z")
      self._update_concentration(z)
      self._monitor(X, z, "gamma")
      if "m" in params:
          self._update_means(X, z)
      self._monitor(X, z, "mu")
      if "c" in params:
          self._update_precisions(X, z)
      self._monitor(X, z, "a and b", end=True)
  
imports: from __future__ import print_function
  import numpy
  from scipy.special import digamma, gammaln
  from scipy import linalg
  from scipy.spatial.distance import cdist
  from ..externals.six.moves import xrange
  from ..utils import check_random_state, check_array, deprecated
  from ..utils.extmath import logsumexp, pinvh, squared_norm
  from ..utils.validation import check_is_fitted
  from ..None import cluster
  from .gmm import _GMMBase
label_desc: Use image node_id 10 for calling the _DPGMMBase obj's underlying member method code with example usage: obj._do_mstep(X, z, params) without return types