dcekit 2.14.2__tar.gz → 2.16.1__tar.gz

{dcekit-2.14.2/dcekit.egg-info → dcekit-2.16.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: dcekit
-Version: 2.14.2
+Version: 2.16.1
 Summary: Data Chemical Engineering toolkit
 Home-page: https://github.com/hkaneko1985/dcekit/
 Author: Hiromasa Kaneko
@@ -38,6 +38,7 @@ Dynamic: author-email
 Dynamic: description
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: summary
 

{dcekit-2.14.2 → dcekit-2.16.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.14.2 → dcekit-2.16.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.14.2 → dcekit-2.16.1}/dcekit/generative_model/vbgmr.py

@@ -25,11 +25,11 @@ class VBGMR(BayesianGaussianMixture):
     def __init__(self, n_components=30, covariance_type='full',
                  weight_concentration_prior_type='dirichlet_process',
                  weight_concentration_prior=0.01, rep='mean', max_iter=100,
-                 random_state=None, display_flag=False):
+                 init_params='kmeans', random_state=None, display_flag=False):
         super(self.__class__, self).__init__(n_components=n_components, covariance_type=covariance_type,
                                     weight_concentration_prior_type=weight_concentration_prior_type,
                                     weight_concentration_prior=weight_concentration_prior,
-                                    max_iter=max_iter, random_state=random_state)
+                                    init_params=init_params, max_iter=max_iter, random_state=random_state)
 
         self.rep = rep
         self.display_flag = display_flag
@@ -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
     
@@ -327,6 +327,109 @@ class VBGMR(BayesianGaussianMixture):
 
         return estimated_means, estimated_covariances, weights
     
+    def predict_mog_pdf(self, dataset, numbers_of_input_variables, numbers_of_output_variables):
+        """
+        Variational Bayesian Gaussian Mixture Regression (VBGMR) based on Variational Bayesian Gaussian Mixture Model (VBGMM)
+        
+        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))
+        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]])
+        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, :]
+            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, :, :])
+                    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')
+                    
+            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)
+            ioe = -logsumexp(logpdfs, axis=0, b=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, weight_concentration_prior_types, weight_concentration_priors, fold_number):
         """

{dcekit-2.14.2 → dcekit-2.16.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.14.2 → dcekit-2.16.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.14.2 → dcekit-2.16.1/dcekit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: dcekit
-Version: 2.14.2
+Version: 2.16.1
 Summary: Data Chemical Engineering toolkit
 Home-page: https://github.com/hkaneko1985/dcekit/
 Author: Hiromasa Kaneko
@@ -38,6 +38,7 @@ Dynamic: author-email
 Dynamic: description
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: summary
 

{dcekit-2.14.2 → dcekit-2.16.1}/setup.py

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