dcekit 2.15.1__tar.gz → 2.17.1__tar.gz

{dcekit-2.15.1/dcekit.egg-info → dcekit-2.17.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dcekit
-Version: 2.15.1
+Version: 2.17.1
 Summary: Data Chemical Engineering toolkit
 Home-page: https://github.com/hkaneko1985/dcekit/
 Author: Hiromasa Kaneko

{dcekit-2.15.1 → dcekit-2.17.1}/dcekit/generative_model/__init__.py

@@ -7,3 +7,5 @@
 from .gmr import GMR
 from .gtm import GTM
 from .vbgmr import VBGMR
+from .ssgmr_xgmm import SSGMRXGMM
+from .ssgmr_xgmm_xma import SSGMRXGMMXMA

{dcekit-2.15.1 → dcekit-2.17.1}/dcekit/generative_model/gmr.py

@@ -24,8 +24,10 @@ warnings.simplefilter('ignore')
 class GMR(GaussianMixture):
 
     def __init__(self, n_components=1, covariance_type='full', rep='mean',
+                 weights_init=None, means_init=None, precisions_init=None,
                  max_iter=100, random_state=None, display_flag=False):
         super(self.__class__, self).__init__(n_components=n_components, covariance_type=covariance_type,
+                                  weights_init=weights_init, means_init=means_init, precisions_init=precisions_init,
                                   max_iter=max_iter, random_state=random_state)
         
         self.rep = rep
@@ -123,9 +125,9 @@ class GMR(GaussianMixture):
         """
 
         mode_of_estimated_mean, weighted_estimated_mean, _, _ = self.predict(dataset, numbers_of_input_variables, numbers_of_output_variables)
-        if self.rep == 'mean':
+        if self.rep == 'mode':
             values = mode_of_estimated_mean.copy()
-        elif self.rep == 'mode':
+        elif self.rep == 'mean':
             values = weighted_estimated_mean.copy()
         return values
     
@@ -301,7 +303,6 @@ class GMR(GaussianMixture):
         Parameters
         ----------
         gmm_model: mixture.gaussian_mixture.GaussianMixture
-            GMM model constructed using scikit-learn
         dataset: numpy.array or pandas.DataFrame
             (autoscaled) m x n matrix of dataset of training data or test data,
             m is the number of sammples and
@@ -363,6 +364,104 @@ class GMR(GaussianMixture):
             l x m matrix of weights,
         """
 
+        dataset = np.array(dataset)
+        if dataset.ndim == 0:
+            dataset = np.reshape(dataset, (1, 1))
+        elif dataset.ndim == 1:
+            dataset = np.reshape(dataset, (1, dataset.shape[0]))
+
+        input_means = self.means_[:, numbers_of_input_variables]
+        output_means = self.means_[:, numbers_of_output_variables]
+        
+        if self.covariance_type == 'full':
+            all_covariances = self.covariances_
+        elif self.covariance_type == 'diag':
+            all_covariances = np.empty(
+                [self.n_components, self.covariances_.shape[1], self.covariances_.shape[1]])
+            for component_number in range(self.n_components):
+                all_covariances[component_number, :, :] = np.diag(self.covariances_[component_number, :])
+        elif self.covariance_type == 'tied':
+            all_covariances = np.tile(self.covariances_, (self.n_components, 1, 1))
+        elif self.covariance_type == 'spherical':
+            all_covariances = np.empty([self.n_components, self.means_.shape[1], self.means_.shape[1]])
+            for component_number in range(self.n_components):
+                all_covariances[component_number, :, :] = np.diag(
+                    self.covariances_[component_number] * np.ones(self.means_.shape[1]))
+
+        estimated_means = np.zeros([self.n_components, dataset.shape[0], len(numbers_of_output_variables)])
+        estimated_covariances = np.zeros([self.n_components, len(numbers_of_output_variables), len(numbers_of_output_variables)])
+        weights = np.zeros([self.n_components, dataset.shape[0]])
+#        print(all_covariances.shape[2], len(numbers_of_input_variables), len(numbers_of_output_variables))
+        if all_covariances.shape[2] == len(numbers_of_input_variables) + len(numbers_of_output_variables):
+            input_output_covariances = all_covariances[:, numbers_of_input_variables, :]
+            input_covariances = input_output_covariances[:, :, numbers_of_input_variables]
+            input_output_covariances = input_output_covariances[:, :, numbers_of_output_variables]
+            output_input_covariances = all_covariances[:, numbers_of_output_variables, :]
+            output_covariances = output_input_covariances[:, :, numbers_of_output_variables]
+            output_input_covariances = output_input_covariances[:, :, numbers_of_input_variables]
+            
+            # estimated means and weights for all components
+            for component_number in range(self.n_components):
+                estimated_means[component_number, :, :] = output_means[component_number, :] + (
+                        dataset - input_means[component_number, :]).dot(
+                    np.linalg.inv(input_covariances[component_number, :, :])).dot(
+                    input_output_covariances[component_number, :, :])
+                estimated_covariances[component_number, :, :] = output_covariances[component_number, :, :] - output_input_covariances[component_number, :, :].dot(
+                        np.linalg.inv(input_covariances[component_number, :, :])).dot(input_output_covariances[component_number, :, :])
+                try:
+                    weights[component_number, :] = self.weights_[component_number] * \
+                                                   multivariate_normal.pdf(dataset,
+                                                                           input_means[component_number, :],
+                                                                           input_covariances[component_number, :, :])
+                except:
+                    print('assignment of weights is failed, and zero is assigned')
+                   
+            if len(np.where(weights.sum(axis=0)==0)[0]) > 0:
+                weights = np.ones(weights.shape)
+            if np.isnan(weights.sum(axis=0)).any():
+                weights = np.ones(weights.shape)
+            if np.isinf(weights.sum(axis=0)).any():
+                weights = np.ones(weights.shape)
+            weights = weights / weights.sum(axis=0)
+            
+        return estimated_means, estimated_covariances, weights
+    
+    def predict_mog_pdf(self, dataset, numbers_of_input_variables, numbers_of_output_variables):
+        """
+        Gaussian Mixture Regression (GMR) based on Gaussian Mixture Model (GMM)
+        
+        Predict values of variables for forward analysis (regression) and inverse analysis. Predition results are given as mixture of Gaussians
+    
+        Parameters
+        ----------
+        gmm_model: mixture.gaussian_mixture.GaussianMixture
+            GMM model constructed using scikit-learn
+        dataset: numpy.array or pandas.DataFrame
+            (autoscaled) m x n matrix of dataset of training data or test data,
+            m is the number of sammples and
+            n is the number of input variables
+            When this is X-variables, it is forward analysis (regression) and
+            when this is Y-variables, it is inverse analysis
+        numbers_of_input_variables: list
+            vector of numbers of input variables
+            When this is numbers of X-variables, it is forward analysis (regression) and
+            when this is numbers of Y-variables, it is inverse analysis
+        numbers_of_output_variables: list
+            vector of numbers of output variables
+            When this is numbers of Y-variables, it is forward analysis (regression) and
+            when this is numbers of X-variables, it is inverse analysis
+    
+        Returns
+        -------
+        estimated_means : numpy.array
+            (autoscaled) l x m x k matrix of output variables estimated for all components,
+            k is the number of output variables
+        estimated_covariances : numpy.array
+            (autoscaled) l x k x k variance-covariance matrix of output variables estimated for all components,
+        weights : numpy.array
+            l x m matrix of weights,
+        """
+
         dataset = np.array(dataset)
         if dataset.ndim == 0:
             dataset = np.reshape(dataset, (1, 1))
@@ -390,6 +489,9 @@ class GMR(GaussianMixture):
         estimated_means = np.zeros([self.n_components, dataset.shape[0], len(numbers_of_output_variables)])
         estimated_covariances = np.zeros([self.n_components, len(numbers_of_output_variables), len(numbers_of_output_variables)])
         weights = np.zeros([self.n_components, dataset.shape[0]])
+        pdfs = np.zeros([self.n_components, dataset.shape[0]])
+        logpdfs = np.zeros([self.n_components, dataset.shape[0]])
+
 #        print(all_covariances.shape[2], len(numbers_of_input_variables), len(numbers_of_output_variables))
         if all_covariances.shape[2] == len(numbers_of_input_variables) + len(numbers_of_output_variables):
             input_output_covariances = all_covariances[:, numbers_of_input_variables, :]
@@ -412,6 +514,8 @@ class GMR(GaussianMixture):
                                                    multivariate_normal.pdf(dataset,
                                                                            input_means[component_number, :],
                                                                            input_covariances[component_number, :, :])
+                    pdfs[component_number, :] = multivariate_normal.pdf(dataset, input_means[component_number, :], input_covariances[component_number, :, :])
+                    logpdfs[component_number, :] = multivariate_normal.logpdf(dataset, input_means[component_number, :], input_covariances[component_number, :, :])
                 except:
                     print('assignment of weights is failed, and zero is assigned')
                    
@@ -422,8 +526,9 @@ class GMR(GaussianMixture):
             if np.isinf(weights.sum(axis=0)).any():
                 weights = np.ones(weights.shape)
             weights = weights / weights.sum(axis=0)
+            ioe = -logsumexp(logpdfs, axis=0, b=weights)
 
-        return estimated_means, estimated_covariances, weights
+        return estimated_means, estimated_covariances, weights, pdfs, logpdfs, ioe
     
     def cv_opt(self, dataset, numbers_of_input_variables, numbers_of_output_variables, covariance_types,
                numbers_of_components, fold_number):

{dcekit-2.15.1 → dcekit-2.17.1}/dcekit/generative_model/gtm.py

@@ -627,7 +627,7 @@ class GTM:
                 if bo_iter == 0: # 最初の試行ではD最適基準を計算
                     # D最適基準の計算
                     param_std = params_df.std(axis=0, ddof=1)
-                    param_std[np.where(param_std == 0)[0]] = 1
+                    param_std.iloc[np.where(param_std == 0)[0]] = 1
                     autoscaled_params_df = (params_df - params_df.mean(axis=0)) / param_std # 計算のために標準化
             
                     all_indexes = list(range(autoscaled_params_df.shape[0])) # indexを取得
@@ -748,7 +748,7 @@ class GTM:
                 for bo_sample_number in range(bo_number_of_selecting_samples):
                     # オートスケーリング
                     x_std = bo_x_data.std(axis=0, ddof=1)
-                    x_std[np.where(x_std == 0)[0]] = 1
+                    x_std.iloc[np.where(x_std == 0)[0]] = 1
                     autoscaled_bo_y_data = (bo_y_data - bo_y_data.mean()) / bo_y_data.std()
                     autoscaled_bo_x_data = (bo_x_data - bo_x_data.mean()) / x_std
                     autoscaled_bo_x_prediction = (bo_x_prediction - bo_x_data.mean()) / x_std
@@ -937,7 +937,7 @@ class GTM:
                 if bo_iter == 0: # 最初の試行ではD最適基準を計算
                     # D最適基準の計算
                     param_std = params_df.std(axis=0, ddof=1)
-                    param_std[np.where(param_std == 0)[0]] = 1
+                    param_std.iloc[np.where(param_std == 0)[0]] = 1
                     autoscaled_params_df = (params_df - params_df.mean(axis=0)) / param_std # 計算のために標準化
             
                     all_indexes = list(range(autoscaled_params_df.shape[0])) # indexを取得
@@ -1004,8 +1004,8 @@ class GTM:
                     else:
     #                    k3nerror_of_gtm = 10 ** 100
                         k3nerror_of_gtm = (np.random.rand()/10 + 1) * 50
-    
-                    params_with_score_df['k3nerror score'].loc[selected_params_idx] = k3nerror_of_gtm # データの保存
+                    
+                    params_with_score_df.loc[selected_params_idx, 'k3nerror score'] = k3nerror_of_gtm # データの保存
                     
                 if bo_display_flag:
                     print('Best k3n-error :', params_with_score_df['k3nerror score'].min())
@@ -1016,7 +1016,7 @@ class GTM:
                     break
                         
                 # Bayesian optimization
-                bo_x_data = bo_params_df.copy() # GP学習用データはGMRの結果があるサンプル
+                bo_x_data = bo_params_df.copy() # GP学習用データはGTMの結果があるサンプル
                 bo_x_prediction = remaining_params_df.copy() # predictionは選択されていない（GMRの結果がない）サンプル
                 bo_y_data = params_with_score_df.loc[bo_params_df.index, 'k3nerror score'] # yはGMRのr2cv
                 
@@ -1039,7 +1039,7 @@ class GTM:
                 for bo_sample_number in range(bo_number_of_selecting_samples):
                     # オートスケーリング
                     x_std = bo_x_data.std(axis=0, ddof=1)
-                    x_std[np.where(x_std == 0)[0]] = 1
+                    x_std.iloc[np.where(x_std == 0)[0]] = 1
                     autoscaled_bo_y_data = (bo_y_data - bo_y_data.mean()) / bo_y_data.std()
                     autoscaled_bo_x_data = (bo_x_data - bo_x_data.mean()) / x_std
                     autoscaled_bo_x_prediction = (bo_x_prediction - bo_x_data.mean()) / x_std
@@ -1125,6 +1125,7 @@ class GTM:
             self.shape_of_rbf_centers = [shape_of_rbf_centers, shape_of_rbf_centers]
             self.variance_of_rbfs = variance_of_rbfs
             self.lambda_in_em_algorithm = lambda_in_em
+            self.rep = 'mean'
             self.k3nerror = params_with_score_df_best['k3nerror score']
         if bo_display_flag:
             self.display_flag = True

dcekit-2.17.1/dcekit/generative_model/ssgmr_xgmm.py

@@ -0,0 +1,696 @@
+# -*- coding: utf-8 -*-
+"""
+@author: Hiromasa Kaneko
+"""
+
+# Semi-supervised Gaussian Mixture Regression with x-only GMM pretraining
+# (ssGMR-xGMM)
+
+import numpy as np
+from sklearn.mixture import GaussianMixture
+
+from .gmr import GMR
+
+
+_VALID_COVARIANCE_TYPES = ('full', 'diag', 'tied', 'spherical')
+
+
+def _as_2d_float_array(values, name, allow_one_dimensional=False):
+    """Convert input data to a finite two-dimensional float array."""
+    array = np.asarray(values, dtype=float)
+    if array.ndim == 1 and allow_one_dimensional:
+        array = array.reshape(-1, 1)
+    if array.ndim != 2:
+        raise ValueError('{0} must be a two-dimensional array.'.format(name))
+    if array.shape[0] == 0 or array.shape[1] == 0:
+        raise ValueError('{0} must not be empty.'.format(name))
+    if not np.all(np.isfinite(array)):
+        raise ValueError('{0} contains NaN or infinite values.'.format(name))
+    return array
+
+
+def _validate_variable_numbers(numbers, number_of_variables, name):
+    """Validate variable-number lists used by DCEKit GMR."""
+    values = np.asarray(numbers, dtype=int).reshape(-1)
+    if values.size == 0:
+        raise ValueError('{0} must contain at least one variable number.'.format(name))
+    if np.unique(values).size != values.size:
+        raise ValueError('{0} contains duplicated variable numbers.'.format(name))
+    if np.any(values < 0) or np.any(values >= number_of_variables):
+        raise ValueError(
+            '{0} contains a variable number outside [0, {1}].'.format(
+                name, number_of_variables - 1
+            )
+        )
+    return values
+
+
+def _make_symmetric_positive_definite(matrix, minimum_eigenvalue):
+    """Symmetrize a matrix and clip its eigenvalues to a positive floor."""
+    matrix = np.asarray(matrix, dtype=float)
+    matrix = 0.5 * (matrix + matrix.T)
+    eigenvalues, eigenvectors = np.linalg.eigh(matrix)
+    eigenvalues = np.maximum(eigenvalues, minimum_eigenvalue)
+    matrix = (eigenvectors * eigenvalues).dot(eigenvectors.T)
+    return 0.5 * (matrix + matrix.T)
+
+
+def _stabilize_joint_covariance(
+        covariance_x, covariance_xy, covariance_y, minimum_eigenvalue):
+    """
+    Construct a positive-definite block covariance while preserving the x and
+    y marginal covariance matrices. The cross-covariance is shrunk only when
+    required by the positive-definite constraint.
+    """
+    covariance_x = _make_symmetric_positive_definite(
+        covariance_x, minimum_eigenvalue
+    )
+    covariance_y = _make_symmetric_positive_definite(
+        covariance_y, minimum_eigenvalue
+    )
+    covariance_xy = np.asarray(covariance_xy, dtype=float)
+
+    cholesky_x = np.linalg.cholesky(covariance_x)
+    cholesky_y = np.linalg.cholesky(covariance_y)
+
+    # The block matrix is positive definite if all singular values of
+    # Lx^-1 Sxy Ly^-T are smaller than one.
+    normalized_cross_covariance = np.linalg.solve(
+        cholesky_x, covariance_xy
+    )
+    normalized_cross_covariance = np.linalg.solve(
+        cholesky_y, normalized_cross_covariance.T
+    ).T
+    singular_values = np.linalg.svd(
+        normalized_cross_covariance, compute_uv=False
+    )
+    largest_singular_value = (
+        singular_values[0] if singular_values.size else 0.0
+    )
+
+    cross_covariance_scaling = 1.0
+    maximum_allowed_singular_value = 1.0 - 1e-8
+    if largest_singular_value >= maximum_allowed_singular_value:
+        cross_covariance_scaling = (
+            maximum_allowed_singular_value / largest_singular_value
+        )
+        covariance_xy = covariance_xy * cross_covariance_scaling
+
+    number_of_x_variables = covariance_x.shape[0]
+    number_of_y_variables = covariance_y.shape[0]
+    covariance = np.zeros(
+        (number_of_x_variables + number_of_y_variables,
+         number_of_x_variables + number_of_y_variables),
+        dtype=float,
+    )
+    covariance[:number_of_x_variables, :number_of_x_variables] = covariance_x
+    covariance[:number_of_x_variables, number_of_x_variables:] = covariance_xy
+    covariance[number_of_x_variables:, :number_of_x_variables] = covariance_xy.T
+    covariance[number_of_x_variables:, number_of_x_variables:] = covariance_y
+    covariance = 0.5 * (covariance + covariance.T)
+    return covariance, cross_covariance_scaling
+
+
+def _covariances_to_precisions(covariances, covariance_type):
+    """Convert covariance parameters to the precisions_init representation."""
+    if covariance_type == 'full':
+        number_of_components, number_of_variables, _ = covariances.shape
+        identity = np.eye(number_of_variables)
+        precisions = np.empty_like(covariances)
+        for component_number in range(number_of_components):
+            precision = np.linalg.solve(
+                covariances[component_number], identity
+            )
+            precisions[component_number] = 0.5 * (
+                precision + precision.T
+            )
+        return precisions
+    if covariance_type == 'tied':
+        identity = np.eye(covariances.shape[0])
+        precision = np.linalg.solve(covariances, identity)
+        return 0.5 * (precision + precision.T)
+    if covariance_type in ('diag', 'spherical'):
+        return 1.0 / covariances
+    raise ValueError('Invalid covariance_type: {0}'.format(covariance_type))
+
+
+def _estimate_covariances_given_means(
+        dataset, responsibilities, effective_sample_sizes, means,
+        reg_covar, covariance_type):
+    """
+    Estimate covariance parameters with means supplied externally.
+
+    This helper is also used by ssGMR-xGMM-xMA after replacing the x-side
+    means with their anchors.
+    """
+    dataset = np.asarray(dataset, dtype=float)
+    responsibilities = np.asarray(responsibilities, dtype=float)
+    means = np.asarray(means, dtype=float)
+    number_of_samples, number_of_variables = dataset.shape
+    number_of_components = responsibilities.shape[1]
+
+    if covariance_type == 'full':
+        covariances = np.empty(
+            (number_of_components, number_of_variables, number_of_variables),
+            dtype=float,
+        )
+        for component_number in range(number_of_components):
+            centered_dataset = dataset - means[component_number]
+            covariance = (
+                centered_dataset.T * responsibilities[:, component_number]
+            ).dot(centered_dataset) / effective_sample_sizes[component_number]
+            covariance = 0.5 * (covariance + covariance.T)
+            covariance.flat[::number_of_variables + 1] += reg_covar
+            covariances[component_number] = covariance
+        return covariances
+
+    if covariance_type == 'tied':
+        covariance = np.zeros(
+            (number_of_variables, number_of_variables), dtype=float
+        )
+        for component_number in range(number_of_components):
+            centered_dataset = dataset - means[component_number]
+            covariance += (
+                centered_dataset.T * responsibilities[:, component_number]
+            ).dot(centered_dataset)
+        covariance /= responsibilities.sum()
+        covariance = 0.5 * (covariance + covariance.T)
+        covariance.flat[::number_of_variables + 1] += reg_covar
+        return covariance
+
+    if covariance_type == 'diag':
+        covariances = np.empty(
+            (number_of_components, number_of_variables), dtype=float
+        )
+        for component_number in range(number_of_components):
+            centered_dataset = dataset - means[component_number]
+            covariances[component_number] = (
+                responsibilities[:, component_number, np.newaxis]
+                * centered_dataset ** 2
+            ).sum(axis=0) / effective_sample_sizes[component_number]
+        covariances += reg_covar
+        return covariances
+
+    if covariance_type == 'spherical':
+        covariances = np.empty(number_of_components, dtype=float)
+        for component_number in range(number_of_components):
+            centered_dataset = dataset - means[component_number]
+            covariances[component_number] = (
+                responsibilities[:, component_number]
+                * np.sum(centered_dataset ** 2, axis=1)
+            ).sum() / (
+                effective_sample_sizes[component_number] * number_of_variables
+            )
+        covariances += reg_covar
+        return covariances
+
+    raise ValueError('Invalid covariance_type: {0}'.format(covariance_type))
+
+
+def _compute_precision_cholesky(covariances, covariance_type):
+    """
+    Compute precision Cholesky factors using scikit-learn's convention.
+
+    For full and tied covariances, the returned matrix is inv(L).T where
+    covariance = L L.T.
+    """
+    if covariance_type == 'full':
+        number_of_components, number_of_variables, _ = covariances.shape
+        identity = np.eye(number_of_variables)
+        precision_cholesky = np.empty_like(covariances)
+        for component_number in range(number_of_components):
+            cholesky = np.linalg.cholesky(covariances[component_number])
+            precision_cholesky[component_number] = np.linalg.solve(
+                cholesky, identity
+            ).T
+        return precision_cholesky
+
+    if covariance_type == 'tied':
+        number_of_variables = covariances.shape[0]
+        cholesky = np.linalg.cholesky(covariances)
+        return np.linalg.solve(cholesky, np.eye(number_of_variables)).T
+
+    if covariance_type in ('diag', 'spherical'):
+        if np.any(covariances <= 0):
+            raise ValueError('Covariances must be positive.')
+        return 1.0 / np.sqrt(covariances)
+
+    raise ValueError('Invalid covariance_type: {0}'.format(covariance_type))
+
+
+class SSGMRXGMM(GMR):
+    """
+    Semi-supervised GMR with x-only GMM pretraining (ssGMR-xGMM).
+
+    A GMM is first fitted to x data that do not require corresponding y
+    measurements. Its weights, x-side means, and x-side covariance structure
+    are then used to initialize a joint GMM fitted to the labeled [x, y]
+    samples. After fitting, all prediction methods inherited from ``GMR`` can
+    be used for forward prediction and direct inverse analysis.
+
+    Parameters
+    ----------
+    n_components : int, default=1
+        Number of Gaussian components.
+    covariance_type : {'full', 'diag', 'tied', 'spherical'}, default='full'
+        Covariance representation used in both the x-only and joint GMMs.
+    rep : {'mean', 'mode'}, default='mean'
+        Representative value returned by ``predict_rep``. ``'mode'`` selects
+        the conditional mean of the component with the largest responsibility;
+        ``'mean'`` returns the responsibility-weighted conditional mean.
+    tol : float, default=1e-3
+        EM convergence tolerance.
+    reg_covar : float, default=1e-6
+        Non-negative regularization added to covariance diagonals.
+    max_iter : int, default=100
+        Maximum number of EM iterations for both GMM stages.
+    x_gmm_n_init : int, default=1
+        Number of initializations for the x-only GMM.
+    init_params : {'kmeans', 'k-means++', 'random', 'random_from_data'},
+            default='kmeans'
+        Initialization method for the x-only GMM.
+    random_state : int, RandomState or None, default=None
+        Random seed.
+    display_flag : bool, default=False
+        DCEKit-compatible display flag used by inherited utility methods.
+    responsibility_floor : float, default=1e-12
+        Small floor applied to x-only responsibilities before calculating
+        y-side initial values.
+    verbose : int, default=0
+        Verbosity passed to scikit-learn's GMM implementation.
+    verbose_interval : int, default=10
+        Interval between verbose messages.
+
+    Notes
+    -----
+    ``labeled_dataset`` and ``x_for_pretraining`` must be expressed in exactly
+    the same x-variable scale and column order. The class intentionally does
+    not autoscale data, matching DCEKit's ``GMR`` behavior.
+    """
+
+    def __init__(
+            self, n_components=1, covariance_type='full', rep='mean',
+            tol=1e-3, reg_covar=1e-6, max_iter=100, x_gmm_n_init=1,
+            init_params='kmeans', random_state=None, display_flag=False,
+            responsibility_floor=1e-12, verbose=0, verbose_interval=10):
+        # GMR.__init__ currently uses super(self.__class__, self), which is not
+        # subclass-safe. Initialize GaussianMixture directly and inherit only
+        # GMR's regression/prediction methods.
+        GaussianMixture.__init__(
+            self,
+            n_components=n_components,
+            covariance_type=covariance_type,
+            tol=tol,
+            reg_covar=reg_covar,
+            max_iter=max_iter,
+            n_init=1,
+            init_params=init_params,
+            weights_init=None,
+            means_init=None,
+            precisions_init=None,
+            random_state=random_state,
+            warm_start=False,
+            verbose=verbose,
+            verbose_interval=verbose_interval,
+        )
+        self.rep = rep
+        self.x_gmm_n_init = x_gmm_n_init
+        self.display_flag = display_flag
+        self.responsibility_floor = responsibility_floor
+
+    def _check_method_parameters(self):
+        if self.covariance_type not in _VALID_COVARIANCE_TYPES:
+            raise ValueError(
+                'covariance_type must be one of {0}.'.format(
+                    _VALID_COVARIANCE_TYPES
+                )
+            )
+        if self.rep not in ('mean', 'mode'):
+            raise ValueError("rep must be either 'mean' or 'mode'.")
+        if not isinstance(self.x_gmm_n_init, (int, np.integer)) \
+                or self.x_gmm_n_init < 1:
+            raise ValueError('x_gmm_n_init must be a positive integer.')
+        if self.responsibility_floor < 0:
+            raise ValueError('responsibility_floor must be non-negative.')
+        if self.reg_covar < 0:
+            raise ValueError('reg_covar must be non-negative.')
+
+    def _prepare_joint_fit(self):
+        """Hook used by ssGMR-xGMM-xMA before joint EM starts."""
+        return None
+
+    def _build_initial_parameters(
+            self, labeled_dataset, x_labeled, y_labeled,
+            numbers_of_x, numbers_of_y):
+        number_of_components = self.n_components
+        number_of_variables = labeled_dataset.shape[1]
+        number_of_x_variables = len(numbers_of_x)
+        number_of_y_variables = len(numbers_of_y)
+        responsibilities = self.x_gmm_.predict_proba(x_labeled)
+        if self.responsibility_floor > 0:
+            responsibilities = np.maximum(
+                responsibilities, self.responsibility_floor
+            )
+            responsibilities /= responsibilities.sum(axis=1, keepdims=True)
+        effective_sample_sizes = responsibilities.sum(axis=0)
+        minimum_effective_sample_size = np.finfo(float).eps * 100
+        effective_sample_sizes = np.maximum(
+            effective_sample_sizes, minimum_effective_sample_size
+        )
+
+        initial_weights = np.asarray(self.x_gmm_.weights_, dtype=float).copy()
+        initial_weights /= initial_weights.sum()
+
+        initial_means = np.zeros(
+            (number_of_components, number_of_variables), dtype=float
+        )
+        initial_means[:, numbers_of_x] = self.x_gmm_.means_
+        initial_y_means = responsibilities.T.dot(y_labeled) \
+            / effective_sample_sizes[:, np.newaxis]
+        initial_means[:, numbers_of_y] = initial_y_means
+
+        minimum_eigenvalue = max(
+            float(self.reg_covar), np.finfo(float).eps * 100
+        )
+        cross_covariance_scaling = np.ones(
+            number_of_components, dtype=float
+        )
+
+        if self.covariance_type == 'full':
+            initial_covariances = np.zeros(
+                (number_of_components, number_of_variables,
+                 number_of_variables),
+                dtype=float,
+            )
+            for component_number in range(number_of_components):
+                sample_weights = responsibilities[:, component_number]
+                centered_x = (
+                    x_labeled - self.x_gmm_.means_[component_number]
+                )
+                centered_y = (
+                    y_labeled - initial_y_means[component_number]
+                )
+                covariance_y = (
+                    centered_y.T * sample_weights
+                ).dot(centered_y) / effective_sample_sizes[component_number]
+                covariance_y = _make_symmetric_positive_definite(
+                    covariance_y, minimum_eigenvalue
+                )
+                covariance_xy = (
+                    centered_x.T * sample_weights
+                ).dot(centered_y) / effective_sample_sizes[component_number]
+                covariance, scaling = _stabilize_joint_covariance(
+                    self.x_gmm_.covariances_[component_number],
+                    covariance_xy,
+                    covariance_y,
+                    minimum_eigenvalue,
+                )
+                cross_covariance_scaling[component_number] = scaling
+                initial_covariances[component_number][
+                    np.ix_(numbers_of_x, numbers_of_x)
+                ] = covariance[
+                    :number_of_x_variables, :number_of_x_variables
+                ]
+                initial_covariances[component_number][
+                    np.ix_(numbers_of_x, numbers_of_y)
+                ] = covariance[
+                    :number_of_x_variables, number_of_x_variables:
+                ]
+                initial_covariances[component_number][
+                    np.ix_(numbers_of_y, numbers_of_x)
+                ] = covariance[
+                    number_of_x_variables:, :number_of_x_variables
+                ]
+                initial_covariances[component_number][
+                    np.ix_(numbers_of_y, numbers_of_y)
+                ] = covariance[
+                    number_of_x_variables:, number_of_x_variables:
+                ]
+
+        elif self.covariance_type == 'diag':
+            initial_covariances = np.zeros(
+                (number_of_components, number_of_variables), dtype=float
+            )
+            initial_covariances[:, numbers_of_x] = self.x_gmm_.covariances_
+            for component_number in range(number_of_components):
+                centered_y = (
+                    y_labeled - initial_y_means[component_number]
+                )
+                y_variances = (
+                    responsibilities[:, component_number, np.newaxis]
+                    * centered_y ** 2
+                ).sum(axis=0) / effective_sample_sizes[component_number]
+                initial_covariances[
+                    component_number, numbers_of_y
+                ] = np.maximum(y_variances, minimum_eigenvalue)
+            initial_covariances = np.maximum(
+                initial_covariances, minimum_eigenvalue
+            )
+
+        elif self.covariance_type == 'tied':
+            covariance_xy_all = np.zeros(
+                (number_of_components, number_of_x_variables,
+                 number_of_y_variables),
+                dtype=float,
+            )
+            covariance_y_all = np.zeros(
+                (number_of_components, number_of_y_variables,
+                 number_of_y_variables),
+                dtype=float,
+            )
+            for component_number in range(number_of_components):
+                sample_weights = responsibilities[:, component_number]
+                centered_x = (
+                    x_labeled - self.x_gmm_.means_[component_number]
+                )
+                centered_y = (
+                    y_labeled - initial_y_means[component_number]
+                )
+                covariance_xy_all[component_number] = (
+                    centered_x.T * sample_weights
+                ).dot(centered_y) / effective_sample_sizes[component_number]
+                covariance_y_all[component_number] = (
+                    centered_y.T * sample_weights
+                ).dot(centered_y) / effective_sample_sizes[component_number]
+
+            component_weights = effective_sample_sizes \
+                / effective_sample_sizes.sum()
+            covariance_xy = np.tensordot(
+                component_weights, covariance_xy_all, axes=(0, 0)
+            )
+            covariance_y = np.tensordot(
+                component_weights, covariance_y_all, axes=(0, 0)
+            )
+            covariance, scaling = _stabilize_joint_covariance(
+                self.x_gmm_.covariances_, covariance_xy, covariance_y,
+                minimum_eigenvalue,
+            )
+            cross_covariance_scaling[:] = scaling
+            initial_covariances = np.zeros(
+                (number_of_variables, number_of_variables), dtype=float
+            )
+            initial_covariances[np.ix_(numbers_of_x, numbers_of_x)] = \
+                covariance[:number_of_x_variables, :number_of_x_variables]
+            initial_covariances[np.ix_(numbers_of_x, numbers_of_y)] = \
+                covariance[:number_of_x_variables, number_of_x_variables:]
+            initial_covariances[np.ix_(numbers_of_y, numbers_of_x)] = \
+                covariance[number_of_x_variables:, :number_of_x_variables]
+            initial_covariances[np.ix_(numbers_of_y, numbers_of_y)] = \
+                covariance[number_of_x_variables:, number_of_x_variables:]
+
+        else:  # spherical
+            initial_covariances = np.zeros(number_of_components, dtype=float)
+            for component_number in range(number_of_components):
+                centered_y = (
+                    y_labeled - initial_y_means[component_number]
+                )
+                y_variances = (
+                    responsibilities[:, component_number, np.newaxis]
+                    * centered_y ** 2
+                ).sum(axis=0) / effective_sample_sizes[component_number]
+                initial_covariances[component_number] = (
+                    number_of_x_variables
+                    * self.x_gmm_.covariances_[component_number]
+                    + np.sum(y_variances)
+                ) / number_of_variables
+            initial_covariances = np.maximum(
+                initial_covariances, minimum_eigenvalue
+            )
+
+        initial_precisions = _covariances_to_precisions(
+            initial_covariances, self.covariance_type
+        )
+        return (
+            initial_weights,
+            initial_means,
+            initial_covariances,
+            initial_precisions,
+            responsibilities,
+            effective_sample_sizes,
+            cross_covariance_scaling,
+        )
+
+    def fit(
+            self, labeled_dataset, x_for_pretraining=None,
+            numbers_of_x=None, numbers_of_y=None):
+        """
+        Fit ssGMR-xGMM.
+
+        Parameters
+        ----------
+        labeled_dataset : array-like of shape (n_labeled, n_x + n_y)
+            Paired, consistently scaled [x, y] samples used for the joint GMM.
+        x_for_pretraining : array-like of shape (n_pretraining, n_x), optional
+            x samples used by the x-only GMM. They may include the labeled x
+            samples, additional unlabeled x samples, and, in a transductive
+            protocol, target-domain test x samples. If omitted, the labeled x
+            samples are used.
+        numbers_of_x : array-like of int
+            Column numbers of x in ``labeled_dataset``.
+        numbers_of_y : array-like of int
+            Column numbers of y in ``labeled_dataset``.
+
+        Returns
+        -------
+        self : SSGMRXGMM
+            Fitted model.
+        """
+        self._check_method_parameters()
+        labeled_dataset = _as_2d_float_array(
+            labeled_dataset, 'labeled_dataset'
+        )
+        number_of_variables = labeled_dataset.shape[1]
+        if numbers_of_x is None or numbers_of_y is None:
+            raise ValueError(
+                'numbers_of_x and numbers_of_y must both be specified.'
+            )
+        numbers_of_x = _validate_variable_numbers(
+            numbers_of_x, number_of_variables, 'numbers_of_x'
+        )
+        numbers_of_y = _validate_variable_numbers(
+            numbers_of_y, number_of_variables, 'numbers_of_y'
+        )
+        if np.intersect1d(numbers_of_x, numbers_of_y).size:
+            raise ValueError('numbers_of_x and numbers_of_y must not overlap.')
+        if not np.array_equal(
+                np.sort(np.r_[numbers_of_x, numbers_of_y]),
+                np.arange(number_of_variables)):
+            raise ValueError(
+                'numbers_of_x and numbers_of_y must jointly cover every '
+                'column of labeled_dataset.'
+            )
+
+        x_labeled = labeled_dataset[:, numbers_of_x]
+        y_labeled = labeled_dataset[:, numbers_of_y]
+        if x_for_pretraining is None:
+            x_for_pretraining = x_labeled
+        else:
+            x_for_pretraining = np.asarray(
+                x_for_pretraining, dtype=float
+            )
+            if x_for_pretraining.ndim == 1 and len(numbers_of_x) == 1:
+                x_for_pretraining = x_for_pretraining.reshape(-1, 1)
+            if x_for_pretraining.ndim != 2:
+                raise ValueError(
+                    'x_for_pretraining must be a two-dimensional array.'
+                )
+            if x_for_pretraining.shape[1] == number_of_variables:
+                # Select x before the finite-value check so that a joint-style
+                # array may contain missing y values.
+                x_for_pretraining = x_for_pretraining[:, numbers_of_x]
+            elif x_for_pretraining.shape[1] != len(numbers_of_x):
+                raise ValueError(
+                    'x_for_pretraining must have either {0} x columns or {1} '
+                    'joint-data columns.'.format(
+                        len(numbers_of_x), number_of_variables
+                    )
+                )
+            x_for_pretraining = _as_2d_float_array(
+                x_for_pretraining, 'x_for_pretraining'
+            )
+
+        if labeled_dataset.shape[0] < self.n_components:
+            raise ValueError(
+                'The number of labeled samples must be at least '
+                'n_components.'
+            )
+        if x_for_pretraining.shape[0] < self.n_components:
+            raise ValueError(
+                'The number of x pretraining samples must be at least '
+                'n_components.'
+            )
+
+        self.numbers_of_x_ = numbers_of_x.copy()
+        self.numbers_of_y_ = numbers_of_y.copy()
+        self.number_of_x_variables_ = len(numbers_of_x)
+        self.number_of_y_variables_ = len(numbers_of_y)
+
+        self.x_gmm_ = GaussianMixture(
+            n_components=self.n_components,
+            covariance_type=self.covariance_type,
+            tol=self.tol,
+            reg_covar=self.reg_covar,
+            max_iter=self.max_iter,
+            n_init=self.x_gmm_n_init,
+            init_params=self.init_params,
+            random_state=self.random_state,
+            warm_start=False,
+            verbose=self.verbose,
+            verbose_interval=self.verbose_interval,
+        )
+        self.x_gmm_.fit(x_for_pretraining)
+
+        (
+            self.initial_weights_,
+            self.initial_means_,
+            self.initial_covariances_,
+            self.initial_precisions_,
+            self.x_responsibilities_for_labeled_samples_,
+            self.x_effective_sample_sizes_,
+            self.cross_covariance_scaling_,
+        ) = self._build_initial_parameters(
+            labeled_dataset,
+            x_labeled,
+            y_labeled,
+            numbers_of_x,
+            numbers_of_y,
+        )
+
+        # GaussianMixture consumes these public initialization attributes.
+        self.weights_init = self.initial_weights_.copy()
+        self.means_init = self.initial_means_.copy()
+        self.precisions_init = np.array(
+            self.initial_precisions_, copy=True
+        )
+        self._prepare_joint_fit()
+
+        # Call GaussianMixture.fit directly to retain GMR's prediction methods
+        # while avoiding GMR.__init__'s subclassing issue.
+        GaussianMixture.fit(self, labeled_dataset)
+        return self
+
+    def fit_from_xy(self, x_labeled, y_labeled, x_for_pretraining=None):
+        """
+        Convenience interface when x and y are supplied as separate arrays.
+        """
+        x_labeled = _as_2d_float_array(
+            x_labeled, 'x_labeled', allow_one_dimensional=True
+        )
+        y_labeled = _as_2d_float_array(
+            y_labeled, 'y_labeled', allow_one_dimensional=True
+        )
+        if x_labeled.shape[0] != y_labeled.shape[0]:
+            raise ValueError(
+                'x_labeled and y_labeled must have the same number of samples.'
+            )
+        labeled_dataset = np.c_[x_labeled, y_labeled]
+        numbers_of_x = np.arange(x_labeled.shape[1])
+        numbers_of_y = np.arange(
+            x_labeled.shape[1], labeled_dataset.shape[1]
+        )
+        return self.fit(
+            labeled_dataset,
+            x_for_pretraining=x_for_pretraining,
+            numbers_of_x=numbers_of_x,
+            numbers_of_y=numbers_of_y,
+        )

dcekit-2.17.1/dcekit/generative_model/ssgmr_xgmm_xma.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+"""
+@author: Hiromasa Kaneko
+"""
+
+# Semi-supervised Gaussian Mixture Regression with x-only GMM pretraining
+# and x-mean anchoring (ssGMR-xGMM-xMA)
+
+import numpy as np
+
+from .ssgmr_xgmm import (
+    SSGMRXGMM,
+    _compute_precision_cholesky,
+    _estimate_covariances_given_means,
+)
+
+
+class SSGMRXGMMXMA(SSGMRXGMM):
+    """
+    Semi-supervised GMR with x-only GMM pretraining and x-mean anchoring.
+
+    Initialization is identical to :class:`SSGMRXGMM`. During every M-step of
+    the joint-GMM EM algorithm, the x-side means are replaced by the x-only GMM
+    means. Mixture weights, y-side means, and all covariance parameters remain
+    trainable. The covariance update is calculated around the anchored means,
+    as specified by ssGMR-xGMM-xMA.
+
+    The constructor and ``fit`` interface are the same as ``SSGMRXGMM``.
+    After fitting, all prediction methods inherited from DCEKit's ``GMR`` can
+    be used for forward prediction and direct inverse analysis.
+    """
+
+    def _prepare_joint_fit(self):
+        self.x_mean_anchors_ = self.initial_means_[
+            :, self.numbers_of_x_
+        ].copy()
+
+    def _m_step(self, dataset, log_responsibilities, xp=None):
+        """M-step with hard anchoring of the x-side component means."""
+        dataset = np.asarray(dataset, dtype=float)
+        log_responsibilities = np.asarray(
+            log_responsibilities, dtype=float
+        )
+        responsibilities = np.exp(log_responsibilities)
+        effective_sample_sizes = responsibilities.sum(axis=0)
+        effective_sample_sizes += 10 * np.finfo(float).eps
+
+        self.weights_ = effective_sample_sizes \
+            / effective_sample_sizes.sum()
+        means = responsibilities.T.dot(dataset) \
+            / effective_sample_sizes[:, np.newaxis]
+        means[:, self.numbers_of_x_] = self.x_mean_anchors_
+        self.means_ = means
+
+        self.covariances_ = _estimate_covariances_given_means(
+            dataset,
+            responsibilities,
+            effective_sample_sizes,
+            self.means_,
+            self.reg_covar,
+            self.covariance_type,
+        )
+        self.precisions_cholesky_ = _compute_precision_cholesky(
+            self.covariances_, self.covariance_type
+        )

{dcekit-2.15.1 → dcekit-2.17.1}/dcekit/generative_model/vbgmr.py

@@ -132,9 +132,9 @@ class VBGMR(BayesianGaussianMixture):
         """
         
         mode_of_estimated_mean, weighted_estimated_mean, _, _ = self.predict(dataset, numbers_of_input_variables, numbers_of_output_variables)
-        if self.rep == 'mean':
+        if self.rep == 'mode':
             values = mode_of_estimated_mean.copy()
-        elif self.rep == 'mode':
+        elif self.rep == 'mean':
             values = weighted_estimated_mean.copy()
         return values
     

{dcekit-2.15.1 → dcekit-2.17.1}/dcekit/variable_selection/basic_variable_selection.py

@@ -103,7 +103,7 @@ def clustering_based_on_correlation_coefficients(x, threshold_of_r):
     distance_in_x = 1 / r_in_x
 
     # clustering
-    clustering = AgglomerativeClustering(n_clusters=None, affinity='precomputed', compute_full_tree='True',
+    clustering = AgglomerativeClustering(n_clusters=None, metric='precomputed', compute_full_tree='auto',
                                          distance_threshold=1 / threshold_of_r, linkage='complete')
     clustering.fit(distance_in_x)
     cluster_numbers = clustering.labels_

{dcekit-2.15.1 → dcekit-2.17.1}/dcekit/variable_selection/variable_importance.py

@@ -88,7 +88,11 @@ def cvpfi(
                             corr_variable_all = X[:, corr_variable_number].copy()                            
                             for sample_number in range(x_test.shape[0]):
                                 if np.random.rand(1)[0] < target_x_corr[corr_variable_number]:
-                                    x_test_shuffled[sample_number, corr_variable_number] = np.random.choice(corr_variable_all, 1, replace=replace)
+                                    tmp = np.random.choice(corr_variable_all, 1, replace=replace)
+                                    if len(tmp)== 1:
+                                        x_test_shuffled[sample_number, corr_variable_number] = tmp[0]
+                                    else:
+                                        x_test_shuffled[sample_number, corr_variable_number] = tmp
                                 
                 estimated_y_test_shuffled = estimator_copy.predict(x_test_shuffled)
                 if y.ndim == 1:
@@ -115,11 +119,12 @@ def cvpfi(
             accuracy_cv = accuracy_score(y, estimated_y_in_cv)
         else:
             accuracy_cv = accuracy_score(np.ravel(y), np.ravel(estimated_y_in_cv))
-#        print(accuracy_score)
+        print(accuracy_cv)
         for variable_number in range(X.shape[1]):
             for n_repeat in range(n_repeats):
 #                print(accuracy_score(y, estimated_y_in_cv_shuffled[:, n_repeat, variable_number]))
                 if y.ndim == 1:
+                    print(accuracy_score(y, estimated_y_in_cv_shuffled[:, n_repeat, variable_number]))
                     importances[variable_number, n_repeat] = accuracy_cv - accuracy_score(y, estimated_y_in_cv_shuffled[:, n_repeat, variable_number])
                 else:
                     importances[variable_number, n_repeat] = accuracy_cv - accuracy_score(np.ravel(y), np.ravel(estimated_y_in_cv_shuffled[:, :, n_repeat, variable_number]))
@@ -202,7 +207,11 @@ def cvpfi_gmr(
                             corr_variable_all = X[:, corr_variable_number].copy()                            
                             for sample_number in range(x_test.shape[0]):
                                 if np.random.rand(1)[0] < target_x_corr[corr_variable_number]:
-                                    x_test_shuffled[sample_number, corr_variable_number] = np.random.choice(corr_variable_all, 1, replace=replace)
+                                    tmp = np.random.choice(corr_variable_all, 1, replace=replace)
+                                    if len(tmp)== 1:
+                                        x_test_shuffled[sample_number, corr_variable_number] = tmp[0]
+                                    else:
+                                        x_test_shuffled[sample_number, corr_variable_number] = tmp
                 estimated_y_in_cv_shuffled[fold_index==fold_number_in_outer_cv, :, n_repeat, variable_number] = estimator_copy.predict_rep(x_test_shuffled, numbers_of_x, numbers_of_y)
     
     importances = np.zeros([X.shape[1], n_repeats])

{dcekit-2.15.1 → dcekit-2.17.1/dcekit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dcekit
-Version: 2.15.1
+Version: 2.17.1
 Summary: Data Chemical Engineering toolkit
 Home-page: https://github.com/hkaneko1985/dcekit/
 Author: Hiromasa Kaneko

{dcekit-2.15.1 → dcekit-2.17.1}/dcekit.egg-info/SOURCES.txt

@@ -14,6 +14,8 @@ dcekit/design_of_exmeriments/bayesian_optimization.py
 dcekit/generative_model/__init__.py
 dcekit/generative_model/gmr.py
 dcekit/generative_model/gtm.py
+dcekit/generative_model/ssgmr_xgmm.py
+dcekit/generative_model/ssgmr_xgmm_xma.py
 dcekit/generative_model/vbgmr.py
 dcekit/just_in_time/__init__.py
 dcekit/just_in_time/jitpls.py

{dcekit-2.15.1 → dcekit-2.17.1}/setup.py

@@ -13,7 +13,7 @@ with open('LICENSE.txt') as f:
 
 setup(
     name='dcekit',
-    version='2.15.1',
+    version='2.17.1',
     description='Data Chemical Engineering toolkit',
     long_description=readme,
     author='Hiromasa Kaneko',