melage 0.0.68__py3-none-any.whl → 1.0.0__py3-none-any.whl

melage/utils/GMM.py

@@ -1,720 +0,0 @@
-import numpy as np
-from scipy.special import logsumexp
-from scipy import linalg
-from sklearn.cluster import KMeans
-"""
-GMM has been used from
-https://atavory.github.io/ibex/_modules/sklearn/mixture/gaussian_mixture.html
-with some modification
-"""
-
-def _check_precision_positivity(precision, covariance_type):
-    """Check a precision vector is positive-definite."""
-    if np.any(np.less_equal(precision, 0.0)):
-        raise ValueError("'%s precision' should be "
-                         "positive" % covariance_type)
-
-
-def _check_precision_matrix(precision, covariance_type):
-    """Check a precision matrix is symmetric and positive-definite."""
-    if not (np.allclose(precision, precision.T) and
-            np.all(linalg.eigvalsh(precision) > 0.)):
-        raise ValueError("'%s precision' should be symmetric, "
-                         "positive-definite" % covariance_type)
-
-
-def _check_precisions_full(precisions, covariance_type):
-    """Check the precision matrices are symmetric and positive-definite."""
-    for prec in precisions:
-        _check_precision_matrix(prec, covariance_type)
-
-
-
-
-###############################################################################
-# Gaussian mixture parameters estimators (used by the M-Step)
-
-
-
-class GaussianMixture(object):
-    """Gaussian Mixture.
-
-    Representation of a Gaussian mixture model probability distribution.
-    This class allows to estimate the parameters of a Gaussian mixture
-    distribution.
-
-    Read more in the :ref:`User Guide <gmm>`.
-
-    .. versionadded:: 0.18
-
-    Parameters
-    ----------
-    n_components : int, default=1
-        The number of mixture components.
-
-    covariance_type : {'full', 'tied', 'diag', 'spherical'}, default='full'
-        String describing the type of covariance parameters to use.
-        Must be one of:
-
-        'full'
-            each component has its own general covariance matrix
-        'tied'
-            all components share the same general covariance matrix
-        'diag'
-            each component has its own diagonal covariance matrix
-        'spherical'
-            each component has its own single variance
-
-    tol : float, default=1e-3
-        The convergence threshold. EM iterations will stop when the
-        lower bound average gain is below this threshold.
-
-    reg_covar : float, default=1e-6
-        Non-negative regularization added to the diagonal of covariance.
-        Allows to assure that the covariance matrices are all positive.
-
-    max_iter : int, default=100
-        The number of EM iterations to perform.
-
-    n_init : int, default=1
-        The number of initializations to perform. The best results are kept.
-
-    init_params : {'kmeans', 'random'}, default='kmeans'
-        The method used to initialize the weights, the means and the
-        precisions.
-        Must be one of::
-
-            'kmeans' : responsibilities are initialized using kmeans.
-            'random' : responsibilities are initialized randomly.
-
-    weights_init : array-like of shape (n_components, ), default=None
-        The user-provided initial weights.
-        If it is None, weights are initialized using the `init_params` method.
-
-    means_init : array-like of shape (n_components, n_features), default=None
-        The user-provided initial means,
-        If it is None, means are initialized using the `init_params` method.
-
-    precisions_init : array-like, default=None
-        The user-provided initial precisions (inverse of the covariance
-        matrices).
-        If it is None, precisions are initialized using the 'init_params'
-        method.
-        The shape depends on 'covariance_type'::
-
-            (n_components,)                        if 'spherical',
-            (n_features, n_features)               if 'tied',
-            (n_components, n_features)             if 'diag',
-            (n_components, n_features, n_features) if 'full'
-
-    random_state : int, RandomState instance or None, default=None
-        Controls the random seed given to the method chosen to initialize the
-        parameters (see `init_params`).
-        In addition, it controls the generation of random samples from the
-        fitted distribution (see the method `sample`).
-        Pass an int for reproducible output across multiple function calls.
-        See :term:`Glossary <random_state>`.
-
-    warm_start : bool, default=False
-        If 'warm_start' is True, the solution of the last fitting is used as
-        initialization for the next call of fit(). This can speed up
-        convergence when fit is called several times on similar problems.
-        In that case, 'n_init' is ignored and only a single initialization
-        occurs upon the first call.
-        See :term:`the Glossary <warm_start>`.
-
-    verbose : int, default=0
-        Enable verbose output. If 1 then it prints the current
-        initialization and each iteration step. If greater than 1 then
-        it prints also the log probability and the time needed
-        for each step.
-
-    verbose_interval : int, default=10
-        Number of iteration done before the next print.
-
-    Attributes
-    ----------
-    weights_ : array-like of shape (n_components,)
-        The weights of each mixture components.
-
-    means_ : array-like of shape (n_components, n_features)
-        The mean of each mixture component.
-
-    covariances_ : array-like
-        The covariance of each mixture component.
-        The shape depends on `covariance_type`::
-
-            (n_components,)                        if 'spherical',
-            (n_features, n_features)               if 'tied',
-            (n_components, n_features)             if 'diag',
-            (n_components, n_features, n_features) if 'full'
-
-    precisions_ : array-like
-        The precision matrices for each component in the mixture. A precision
-        matrix is the inverse of a covariance matrix. A covariance matrix is
-        symmetric positive definite so the mixture of Gaussian can be
-        equivalently parameterized by the precision matrices. Storing the
-        precision matrices instead of the covariance matrices makes it more
-        efficient to compute the log-likelihood of new samples at test time.
-        The shape depends on `covariance_type`::
-
-            (n_components,)                        if 'spherical',
-            (n_features, n_features)               if 'tied',
-            (n_components, n_features)             if 'diag',
-            (n_components, n_features, n_features) if 'full'
-
-    precisions_cholesky_ : array-like
-        The cholesky decomposition of the precision matrices of each mixture
-        component. A precision matrix is the inverse of a covariance matrix.
-        A covariance matrix is symmetric positive definite so the mixture of
-        Gaussian can be equivalently parameterized by the precision matrices.
-        Storing the precision matrices instead of the covariance matrices makes
-        it more efficient to compute the log-likelihood of new samples at test
-        time. The shape depends on `covariance_type`::
-
-            (n_components,)                        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.
-
-    n_iter_ : int
-        Number of step used by the best fit of EM to reach the convergence.
-
-    lower_bound_ : float
-        Lower bound value on the log-likelihood (of the training data with
-        respect to the model) of the best fit of EM.
-
-    Examples
-    --------
-    >>> import numpy as np
-    >>> from sklearn.mixture import GaussianMixture
-    >>> X = np.array([[1, 2], [1, 4], [1, 0], [10, 2], [10, 4], [10, 0]])
-    >>> gm = GaussianMixture(n_components=2, random_state=0).fit(X)
-    >>> gm.means_
-    array([[10.,  2.],
-           [ 1.,  2.]])
-    >>> gm.predict([[0, 0], [12, 3]])
-    array([1, 0])
-
-    See Also
-    --------
-    BayesianGaussianMixture : Gaussian mixture model fit with a variational
-        inference.
-    """
-    #@_deprecate_positional_args
-    def __init__(self, n_components=1, *, covariance_type='full', tol=1e-3,
-                 reg_covar=1e-6, max_iter=100, n_init=1, init_params='kmeans',
-                 weights_init=None, means_init=None, precisions_init=None,
-                 random_state=None, warm_start=False,
-                 verbose=0, verbose_interval=10):
-     #   super().__init__(
-      #      n_components=n_components, tol=tol, reg_covar=reg_covar,
-       #     max_iter=max_iter, n_init=n_init, init_params=init_params,
-        #    random_state=random_state, warm_start=warm_start,
-         #   verbose=verbose, verbose_interval=verbose_interval)
-
-        self.covariance_type = covariance_type
-        self.weights_init = weights_init
-        self.means_init = means_init
-        self.precisions_init = precisions_init
-
-        self.n_components = n_components
-        self.tol = tol
-        self.reg_covar = reg_covar
-        self.max_iter = max_iter
-        self.n_init = n_init
-        self.init_params = init_params
-        self.random_state = random_state
-        self.warm_start = warm_start
-        self.verbose = verbose
-        self.verbose_interval = verbose_interval
-
-    def _estimate_gaussian_covariances_full(self, resp, X, nk, means, reg_covar):
-        """Estimate the full covariance matrices.
-
-        Parameters
-        ----------
-        resp : array-like of shape (n_samples, n_components)
-
-        X : array-like of shape (n_samples, n_features)
-
-        nk : array-like of shape (n_components,)
-
-        means : array-like of shape (n_components, n_features)
-
-        reg_covar : float
-
-        Returns
-        -------
-        covariances : array, shape (n_components, n_features, n_features)
-            The covariance matrix of the current components.
-        """
-        n_components, n_features = means.shape
-        covariances = np.empty((n_components, n_features, n_features))
-        for k in range(n_components):
-            diff = X - means[k]
-            covariances[k] = np.dot(resp[:, k] * diff.T, diff) / nk[k]
-            covariances[k].flat[::n_features + 1] += reg_covar
-        return covariances
-
-
-
-    def _estimate_gaussian_covariances_diag(self, resp, X, nk, means, reg_covar):
-        """Estimate the diagonal covariance vectors.
-
-        Parameters
-        ----------
-        responsibilities : array-like of shape (n_samples, n_components)
-
-        X : array-like of shape (n_samples, n_features)
-
-        nk : array-like of shape (n_components,)
-
-        means : array-like of shape (n_components, n_features)
-
-        reg_covar : float
-
-        Returns
-        -------
-        covariances : array, shape (n_components, n_features)
-            The covariance vector of the current components.
-        """
-        #X = X * self._counts
-        avg_X2 = np.dot((resp).T, (X * X*self._counts) ) / nk[:, np.newaxis]
-        avg_means2 = means ** 2
-        avg_X_means = means * np.dot(resp.T, X*self._counts) / nk[:, np.newaxis]
-        return avg_X2 - 2 * avg_X_means + avg_means2 + reg_covar
-
-
-    def _estimate_gaussian_parameters(self, X, resp, reg_covar, covariance_type):
-        """Estimate the Gaussian distribution parameters.
-
-        Parameters
-        ----------
-        X : array-like of shape (n_samples, n_features)
-            The input data array.
-
-        resp : array-like of shape (n_samples, n_components)
-            The responsibilities for each data sample in X.
-
-        reg_covar : float
-            The regularization added to the diagonal of the covariance matrices.
-
-        covariance_type : {'full', 'tied', 'diag', 'spherical'}
-            The type of precision matrices.
-
-        Returns
-        -------
-        nk : array-like of shape (n_components,)
-            The numbers of data samples in the current components.
-
-        means : array-like of shape (n_components, n_features)
-            The centers of the current components.
-
-        covariances : array-like
-            The covariance matrix of the current components.
-            The shape depends of the covariance_type.
-        """
-        nk = (resp*self._counts).sum(axis=0) + 10 * np.finfo(resp.dtype).eps
-        means = np.dot(resp.T, X*self._counts)/nk[:,np.newaxis]
-        covariances = {"diag": self._estimate_gaussian_covariances_diag
-                       }[covariance_type](resp, X, nk, means, reg_covar)
-        return nk, means, covariances
-
-    def _compute_precision_cholesky(self, covariances, covariance_type):
-        """Compute the Cholesky decomposition of the precisions.
-
-        Parameters
-        ----------
-        covariances : array-like
-            The covariance matrix of the current components.
-            The shape depends of the covariance_type.
-
-        covariance_type : {'full', 'tied', 'diag', 'spherical'}
-            The type of precision matrices.
-
-        Returns
-        -------
-        precisions_cholesky : array-like
-            The cholesky decomposition of sample precisions of the current
-            components. The shape depends of the covariance_type.
-        """
-        estimate_precision_error_message = (
-            "Fitting the mixture model failed because some components have "
-            "ill-defined empirical covariance (for instance caused by singleton "
-            "or collapsed samples). Try to decrease the number of components, "
-            "or increase reg_covar.")
-
-        if covariance_type == 'full':
-            n_components, n_features, _ = covariances.shape
-            precisions_chol = np.empty((n_components, n_features, n_features))
-            for k, covariance in enumerate(covariances):
-                try:
-                    cov_chol = linalg.cholesky(covariance, lower=True)
-                except linalg.LinAlgError:
-                    raise ValueError(estimate_precision_error_message)
-                precisions_chol[k] = linalg.solve_triangular(cov_chol,
-                                                             np.eye(n_features),
-                                                             lower=True).T
-        elif covariance_type == 'tied':
-            _, n_features = covariances.shape
-            try:
-                cov_chol = linalg.cholesky(covariances, lower=True)
-            except linalg.LinAlgError:
-                raise ValueError(estimate_precision_error_message)
-            precisions_chol = linalg.solve_triangular(cov_chol, np.eye(n_features),
-                                                      lower=True).T
-        else:
-            if np.any(np.less_equal(covariances, 0.0)):
-                raise ValueError(estimate_precision_error_message)
-            precisions_chol = 1. / np.sqrt(covariances)
-        return precisions_chol
-
-    ###############################################################################
-    # Gaussian mixture probability estimators
-    def _compute_log_det_cholesky(self, matrix_chol, covariance_type, n_features):
-        """Compute the log-det of the cholesky decomposition of matrices.
-        """
-
-        if covariance_type == 'diag':
-            log_det_chol = (np.sum(np.log(matrix_chol), axis=1))
-
-
-        return log_det_chol
-
-    def _estimate_log_gaussian_prob(self, X, means, precisions_chol, covariance_type):
-        """Estimate the log Gaussian probability.
-
-        Parameters
-        ----------
-        X : array-like of shape (n_samples, n_features)
-
-        means : array-like of shape (n_components, n_features)
-
-        precisions_chol : array-like
-            Cholesky decompositions of the precision matrices.
-            'full' : shape of (n_components, n_features, n_features)
-            'tied' : shape of (n_features, n_features)
-            'diag' : shape of (n_components, n_features)
-            'spherical' : shape of (n_components,)
-
-        covariance_type : {'full', 'tied', 'diag', 'spherical'}
-
-        Returns
-        -------
-        log_prob : array, shape (n_samples, n_components)
-        """
-        _, n_features = X.shape
-        n_components, _ = means.shape
-        # det(precision_chol) is half of det(precision)
-        log_det = self._compute_log_det_cholesky(
-            precisions_chol, covariance_type, n_features)
-
-
-        if covariance_type == 'diag':
-            precisions = precisions_chol ** 2
-            #if self._counts is not None:
-             #   X = X*self._counts
-            log_prob = (np.sum((means ** 2 * precisions), 1) -
-                        2. * np.dot(X, (means * precisions).T) +
-                        np.dot(X ** 2, precisions.T))
-            if self._counts is not None:
-                log_prob *= self._counts
-
-        return -.5 * (n_features * np.log(2 * np.pi) + log_prob) + log_det
-
-    def fit(self, X, y=None, counts = None, total_data_kmeans=None):
-        """Estimate model parameters with the EM algorithm.
-        """
-        if counts is not None:
-            self._counts = counts.reshape(-1,1)
-            self._total_data_kmeans = total_data_kmeans
-        self.fit_predict(X, y, counts)
-        self._counts = None
-        return self
-
-    def score_samples(self, X):
-        """Compute the weighted log probabilities for each sample.
-
-        """
-
-
-        return logsumexp(self._estimate_weighted_log_prob(X), axis=1)
-
-    def _print_verbose_msg_init_beg(self, n_init):
-        """Print verbose message on initialization."""
-        if self.verbose == 1:
-            print("Initialization %d" % n_init)
-        elif self.verbose >= 2:
-            print("Initialization %d" % n_init)
-            self._init_prev_time = time()
-            self._iter_prev_time = self._init_prev_time
-
-
-
-    def _print_verbose_msg_iter_end(self, n_iter, diff_ll):
-        """Print verbose message on initialization."""
-        if n_iter % self.verbose_interval == 0:
-            if self.verbose == 1:
-                print("  Iteration %d" % n_iter)
-            elif self.verbose >= 2:
-                cur_time = time()
-                print("  Iteration %d\t time lapse %.5fs\t ll change %.5f" % (
-                    n_iter, cur_time - self._iter_prev_time, diff_ll))
-                self._iter_prev_time = cur_time
-
-
-    def _initialize_parameters(self, X, random_state):
-        """Initialize the model parameters.
-
-        Parameters
-        ----------
-        X : array-like of shape  (n_samples, n_features)
-
-        random_state : RandomState
-            A random number generator instance that controls the random seed
-            used for the method chosen to initialize the parameters.
-        """
-        n_samples, _ = X.shape
-
-        if self.init_params == 'kmeans':
-            resp = np.zeros((n_samples, self.n_components))
-            km = KMeans(n_clusters=self.n_components, n_init=1,
-                                   random_state=random_state).fit(self._total_data_kmeans)
-            label = km.predict(X)
-            resp[np.arange(n_samples), label] = 1
-        elif self.init_params == 'random':
-            resp = random_state.rand(n_samples, self.n_components)
-            resp /= resp.sum(axis=1)[:, np.newaxis]
-        else:
-            raise ValueError("Unimplemented initialization method '%s'"
-                             % self.init_params)
-
-        self._initialize(X, resp)
-
-    def _print_verbose_msg_init_end(self, ll):
-        """Print verbose message on the end of iteration."""
-        if self.verbose == 1:
-            print("Initialization converged: %s" % self.converged_)
-        elif self.verbose >= 2:
-            print("Initialization converged: %s\t time lapse %.5fs\t ll %.5f" %
-                  (self.converged_, time() - self._init_prev_time, ll))
-
-
-    def fit_predict(self, X, y=None, counts = None):
-        """Estimate model parameters using X and predict the labels for X.
-        """
-        #X = _check_X(X, self.n_components, ensure_min_samples=2)
-        #self._check_n_features(X, reset=True)
-        #self._check_initial_parameters(X)
-
-        # if we enable warm_start, we will have a unique initialisation
-        do_init = not(self.warm_start and hasattr(self, 'converged_'))
-        n_init = self.n_init if do_init else 1
-
-        max_lower_bound = -np.infty
-        self.converged_ = False
-
-        random_state = np.random.RandomState(self.random_state)
-
-        n_samples, _ = X.shape
-        for init in range(n_init):
-            self._print_verbose_msg_init_beg(init)
-
-            if do_init:
-                self._initialize_parameters(X, random_state)
-
-            lower_bound = (-np.infty if do_init else self.lower_bound_)
-
-            for n_iter in range(1, self.max_iter + 1):
-                prev_lower_bound = lower_bound
-
-                log_prob_norm, log_resp = self._e_step(X, counts=counts)
-                self._m_step(X, log_resp)
-                lower_bound = self._compute_lower_bound(
-                    log_resp, log_prob_norm)
-
-                change = lower_bound - prev_lower_bound
-                self._print_verbose_msg_iter_end(n_iter, change)
-
-                if abs(change) < self.tol:
-                    self.converged_ = True
-                    break
-
-            self._print_verbose_msg_init_end(lower_bound)
-
-            if lower_bound > max_lower_bound:
-                max_lower_bound = lower_bound
-                best_params = self._get_parameters()
-                best_n_iter = n_iter
-
-        if not self.converged_:
-            print('Initialization %d did not converge. '
-                          'Try different init parameters, '
-                          'or increase max_iter, tol '
-                          'or check for degenerate data.'
-                          % (init + 1))
-
-        self._set_parameters(best_params)
-        self.n_iter_ = best_n_iter
-        self.lower_bound_ = max_lower_bound
-
-        # Always do a final e-step to guarantee that the labels returned by
-        # fit_predict(X) are always consistent with fit(X).predict(X)
-        # for any value of max_iter and tol (and any random_state).
-        _, log_resp = self._e_step(X)
-
-        return log_resp.argmax(axis=1)
-
-    def _e_step(self, X, counts=None):
-        """E step.
-        """
-        log_prob_norm, log_resp = self._estimate_log_prob_resp(X)
-        return log_prob_norm.sum()/self._counts.sum(), log_resp
-
-    def _estimate_log_prob_resp(self, X):
-        """Estimate log probabilities and responsibilities for each sample.
-        """
-        weighted_log_prob = self._estimate_weighted_log_prob(X)
-        #if self._counts is not None:
-         #   weighted_log_prob = self._counts * weighted_log_prob
-        log_prob_norm = logsumexp(weighted_log_prob, axis=1)
-        with np.errstate(under='ignore'):
-            # ignore underflow
-            log_resp = weighted_log_prob - log_prob_norm[:, np.newaxis]
-        return log_prob_norm, log_resp
-
-    def _estimate_weighted_log_prob(self, X):
-        """Estimate the weighted log-probabilities, log P(X | Z) + log weights.
-        """
-        return self._estimate_log_prob(X) + self._estimate_log_weights()
-
-    def _initialize(self, X, resp):
-        """Initialization of the Gaussian mixture parameters.
-
-        Parameters
-        ----------
-        X : array-like of shape (n_samples, n_features)
-
-        resp : array-like of shape (n_samples, n_components)
-        """
-        n_samples= self._counts.sum()#X.shape
-
-        weights, means, covariances = self._estimate_gaussian_parameters(
-            X, resp, self.reg_covar, self.covariance_type)
-        weights /= n_samples
-
-        self.weights_ = (weights if self.weights_init is None
-                         else self.weights_init)
-        self.means_ = means if self.means_init is None else self.means_init
-
-        if self.precisions_init is None:
-            self.covariances_ = covariances
-            self.precisions_cholesky_ = self._compute_precision_cholesky(
-                covariances, self.covariance_type)
-        elif self.covariance_type == 'full':
-            self.precisions_cholesky_ = np.array(
-                [linalg.cholesky(prec_init, lower=True)
-                 for prec_init in self.precisions_init])
-        elif self.covariance_type == 'tied':
-            self.precisions_cholesky_ = linalg.cholesky(self.precisions_init,
-                                                        lower=True)
-        else:
-            self.precisions_cholesky_ = self.precisions_init
-
-    def _m_step(self, X, log_resp):
-        """M step.
-
-        Parameters
-        ----------
-        X : array-like of shape (n_samples, n_features)
-
-        log_resp : array-like of shape (n_samples, n_components)
-            Logarithm of the posterior probabilities (or responsibilities) of
-            the point of each sample in X.
-        """
-        n_samples = self._counts.sum()#X.shape
-        self.weights_, self.means_, self.covariances_ = (
-            self._estimate_gaussian_parameters(X, np.exp(log_resp), self.reg_covar,
-                                          self.covariance_type))
-        self.weights_ /= n_samples
-        self.precisions_cholesky_ = self._compute_precision_cholesky(
-            self.covariances_, self.covariance_type)
-
-    def _estimate_log_prob(self, X):
-        return self._estimate_log_gaussian_prob(
-            X, self.means_, self.precisions_cholesky_, self.covariance_type)
-
-    def _estimate_log_weights(self):
-        return np.log(self.weights_)
-
-    def _compute_lower_bound(self, _, log_prob_norm):
-        return log_prob_norm
-
-    def _get_parameters(self):
-        return (self.weights_, self.means_, self.covariances_,
-                self.precisions_cholesky_)
-
-    def _set_parameters(self, params):
-        (self.weights_, self.means_, self.covariances_,
-         self.precisions_cholesky_) = params
-
-        # Attributes computation
-        _, n_features = self.means_.shape
-
-        if self.covariance_type == 'full':
-            self.precisions_ = np.empty(self.precisions_cholesky_.shape)
-            for k, prec_chol in enumerate(self.precisions_cholesky_):
-                self.precisions_[k] = np.dot(prec_chol, prec_chol.T)
-
-        elif self.covariance_type == 'tied':
-            self.precisions_ = np.dot(self.precisions_cholesky_,
-                                      self.precisions_cholesky_.T)
-        else:
-            self.precisions_ = self.precisions_cholesky_ ** 2
-
-    def _n_parameters(self):
-        """Return the number of free parameters in the model."""
-        _, n_features = self.means_.shape
-        if self.covariance_type == 'full':
-            cov_params = self.n_components * n_features * (n_features + 1) / 2.
-        elif self.covariance_type == 'diag':
-            cov_params = self.n_components * n_features
-        elif self.covariance_type == 'tied':
-            cov_params = n_features * (n_features + 1) / 2.
-        elif self.covariance_type == 'spherical':
-            cov_params = self.n_components
-        mean_params = n_features * self.n_components
-        return int(cov_params + mean_params + self.n_components - 1)
-
-    def bic(self, X):
-        """Bayesian information criterion for the current model on the input X.
-
-        Parameters
-        ----------
-        X : array of shape (n_samples, n_dimensions)
-
-        Returns
-        -------
-        bic : float
-            The lower the better.
-        """
-        return (-2 * self.score(X) * X.shape[0] +
-                self._n_parameters() * np.log(X.shape[0]))
-
-    def aic(self, X):
-        """Akaike information criterion for the current model on the input X.
-
-        Parameters
-        ----------
-        X : array of shape (n_samples, n_dimensions)
-
-        Returns
-        -------
-        aic : float
-            The lower the better.
-        """
-        return -2 * self.score(X) * X.shape[0] + 2 * self._n_parameters()