UKRのメモリ消費抑える修正

testfunc.py

@@ -0,0 +1,9 @@
+def func_default(arg1=1, arg2=2, arg3=3):
+    print(arg1)
+    print(arg2)
+    print(arg3)
+
+none_dict = {}
+print('dict type is {}'.format(type(none_dict)))
+print(isinstance(none_dict, dict))
+func_default(4, arg2=2, **none_dict)

tests/ukr/allclose_numpy_vs_pytorch.py

@@ -11,7 +11,7 @@
 
 class TestUKR(unittest.TestCase):
     def test_numpy_vs_pytorch(self):
-        # create artiricial dataset
+        # create artificial dataset
         nb_samples = 500
         seed = 1
         np.random.seed(seed)
@@ -20,14 +20,15 @@ def test_numpy_vs_pytorch(self):
         X += np.random.normal(0, x_sigma, X.shape)
 
         # set parameter
-        n_components_list = [1,2,3]
+        n_components_list = [3]
         bandwidth_gaussian_kernel_list = [0.2, 1.0]
         nb_epoch = 500
 
         is_compact_list = [True, False]
         is_save_history = True
         lambda_list = [0.0, 0.005]
-        eta = 8.0
+        weights_list = [None, np.random.rand(nb_samples)]
+        eta = 7.0
 
         for n_components in n_components_list:
             # initialize Z
@@ -36,22 +37,30 @@ def test_numpy_vs_pytorch(self):
             for bandwidth_gaussian_kernel in bandwidth_gaussian_kernel_list:
                 for is_compact in is_compact_list:
                     for lambda_ in lambda_list:
-                        ukr = UKR(X, n_components=n_components, bandwidth_gaussian_kernel=bandwidth_gaussian_kernel,
-                                  is_compact=is_compact, is_save_history=is_save_history, lambda_=lambda_, init=Zinit)
-                        ukr.fit(nb_epoch=nb_epoch, eta=eta)
-                        all_z = ukr.history['z']
-                        all_obj_func = ukr.history['obj_func']
-
-                        ukr_pytorch = UKR_pytorch(torch.from_numpy(X),
-                                                  nb_components=n_components,
-                                                  bandwidth_gaussian_kernel=bandwidth_gaussian_kernel,
-                                                  is_compact=is_compact, is_save_history=is_save_history, lambda_=lambda_,
-                                                  init=torch.tensor(Zinit, requires_grad=True, dtype=torch.float64))
-                        ukr_pytorch.fit(nb_epoch=nb_epoch, eta=eta)
-                        all_z_pytorch = ukr_pytorch.history['z'].detach().numpy()
-                        all_obj_func_pytorch = ukr_pytorch.history['obj_func'].detach().numpy()
-                        np.testing.assert_allclose(all_z, all_z_pytorch)
-                        np.testing.assert_allclose(all_obj_func,all_obj_func_pytorch)
+                        for weights in weights_list:
+                            ukr = UKR(X, n_components=n_components, bandwidth_gaussian_kernel=bandwidth_gaussian_kernel,
+                                      weights=weights, is_compact=is_compact, is_save_history=is_save_history,
+                                      lambda_=lambda_, init=Zinit)
+                            ukr.fit(nb_epoch=nb_epoch, eta=eta)
+                            all_z = ukr.history['z']
+                            all_obj_func = ukr.history['obj_func']
+
+                            if isinstance(weights, np.ndarray):
+                                weights = torch.from_numpy(weights)
+                            else:
+                                pass
+
+                            ukr_pytorch = UKR_pytorch(torch.from_numpy(X),
+                                                      nb_components=n_components,
+                                                      bandwidth_gaussian_kernel=bandwidth_gaussian_kernel,
+                                                      is_compact=is_compact, is_save_history=is_save_history,
+                                                      lambda_=lambda_, weights=weights,
+                                                      init=torch.tensor(Zinit, requires_grad=True, dtype=torch.float64))
+                            ukr_pytorch.fit(nb_epoch=nb_epoch, eta=eta)
+                            all_z_pytorch = ukr_pytorch.history['z'].detach().numpy()
+                            all_obj_func_pytorch = ukr_pytorch.history['obj_func'].detach().numpy()
+                            np.testing.assert_allclose(all_z, all_z_pytorch)
+                            np.testing.assert_allclose(all_obj_func, all_obj_func_pytorch)
 
 
 if __name__ == "__main__":

tests/ukr/model/unsupervised_kernel_regression_pytorch.py

@@ -1,19 +1,14 @@
 # coding: utf-8
 import sys
 sys.path.append('../')
-#from som.datasets.kura import create_data
-# from KSE.lib.datasets.artificial.spiral import create_data
 
 import numpy as np
 import torch
-import matplotlib.pyplot as plt
-import matplotlib.animation as anim
-from mpl_toolkits.mplot3d import Axes3D
 from tqdm import tqdm
 
 class Unsupervised_Kernel_Regression_pytorch(object):
     def __init__(self, X, nb_components, bandwidth_gaussian_kernel=1.0,
-                 is_compact=False, lambda_=1.0,
+                 is_compact=False, lambda_=1.0, weights=None,
                  init='random', is_loocv=False, is_save_history=False):
         self.X = X.clone()
         self.nb_samples = X.shape[0]
@@ -35,6 +30,11 @@ def __init__(self, X, nb_components, bandwidth_gaussian_kernel=1.0,
 
         self.lambda_ = lambda_
 
+        if weights is None:
+            self.weights = torch.ones(self.nb_samples)
+        else:
+            self.weights = weights
+
         self._done_fit = False
 
     def fit(self, nb_epoch=100, verbose=True, eta=0.5, expand_epoch=None):
@@ -54,7 +54,7 @@ def fit(self, nb_epoch=100, verbose=True, eta=0.5, expand_epoch=None):
 
         for epoch in bar:
             DistZ = torch.sum((self.Z[:, None, :] - self.Z[None, :, :])**2, dim=2)
-            H = torch.exp(-0.5 * self.precision * DistZ)
+            H = torch.exp(-0.5 * self.precision * DistZ) * self.weights[None, :]
             if self.is_loocv:
                 # H -= np.identity(H.shape[0])
                 assert 'Not Implemented Error'
@@ -64,7 +64,7 @@ def fit(self, nb_epoch=100, verbose=True, eta=0.5, expand_epoch=None):
 
             Y = torch.mm(R,self.X)
             Error = Y - self.X
-            obj_func = torch.sum(Error**2) / self.nb_samples + self.lambda_ * torch.sum(self.Z**2)
+            obj_func = torch.sum((Error**2) * self.weights[:, None]) / self.weights.sum() + self.lambda_ * torch.sum(self.Z**2)
             obj_func.backward()
             with torch.no_grad():
                 self.Z = self.Z - eta * self.Z.grad

tutorials/ukr/fitting_animal_data.py

@@ -0,0 +1,39 @@
+from libs.models.unsupervised_kernel_regression import UnsupervisedKernelRegression as UKR
+from libs.datasets.artificial import animal
+from sklearn.utils import check_random_state
+
+if __name__ == '__main__':
+    n_components = 2
+    bandwidth = 0.4
+    lambda_ = 0.0
+    is_compact = True
+    is_save_history = True
+
+    nb_epoch = 1000
+    eta = 0.02
+
+    X, labels_animal, labels_feature = animal.load_data(retlabel_animal=True,
+                                                        retlabel_feature=True)
+
+    seed = 14
+    random_state = check_random_state(seed)
+    init = random_state.normal(0.0, bandwidth * 0.1, size=(X.shape[0], n_components))
+
+    ukr = UKR(X, n_components=n_components, bandwidth_gaussian_kernel=bandwidth,
+              is_compact=is_compact, is_save_history=is_save_history, lambda_=lambda_, init=init)
+    ukr.fit(nb_epoch=nb_epoch, eta=eta)
+
+    params_imshow = {'cmap': 'BrBG',
+                     'interpolation': 'spline16'}
+    params_scatter = {'s': 30, 'marker': 'x'}
+    ukr.visualize(
+        n_grid_points=100,
+        label_data=labels_animal,
+        label_feature=labels_feature,
+        is_middle_color_zero=True,
+        is_show_all_label_data=True,
+        params_imshow=params_imshow,
+        params_scatter=params_scatter,
+        title_latent_space='Animal map (latent space)',
+        title_feature_bars='Animal feature'
+    )

tutorials/ukr/fitting_saddle_shape.py

@@ -38,7 +38,7 @@
               is_compact=is_compact, is_save_history=is_save_history, lambda_=lambda_)
     som.fit(nb_epoch=nb_epoch)
     ukr.fit(nb_epoch=nb_epoch, eta=eta)
-    ukr.calculation_history_of_mapping(resolution=30)
+    ukr.calculate_history_of_mapping(resolution=30)
 
     fig = plt.figure(figsize=[7, 8])
     ax_latent_space_som = fig.add_subplot(2, 2, 1, aspect='equal')