CMTL done

Author: DaPraxis

Vampyr_MTL/functions/MTL_Cluster_Least_L21.py

@@ -11,7 +11,7 @@
 from scipy.sparse import isspmatrix
 
 class MTL_Cluster_Least_L21:
-    def __init__(self, opts, k, rho1=10, rho2=0.2):
+    def __init__(self, opts, k, rho1=10, rho2=0.1):
         self.opts = init_opts(opts)
         self.rho1 = rho1
         self.rho2 = rho2
@@ -44,8 +44,8 @@ def fit(self, X, Y, **kwargs):
         self.XY = [0]* self.task_num
         W0_prep = []
         for t in range(self.task_num):
-            self.XY[i] = X[i] @ Y[i]
-            W0_prep.append(self.XY[i].reshape((-1,1)))
+            self.XY[t] = X[t] @ Y[t]
+            W0_prep.append(self.XY[t].reshape((-1,1)))
         W0_prep = np.hstack(W0_prep)
         if hasattr(self.opts,'W0'):
             W0=self.opts.W0
@@ -65,14 +65,14 @@ def fit(self, X, Y, **kwargs):
         Wz_old = W0
         Mz = M0.toarray()
         Mz_old = M0.toarray()
-        
+          
         t = 1
         t_old = 0
 
         it = 0
         gamma = 1.0
         gamma_inc = 2
-        
+        # for it in trange(2, file=sys.stdout, desc='outer loop'):
         for it in trange(self.opts.maxIter, file=sys.stdout, desc='outer loop'):
             alpha = (t_old - 1)/t
             Ws = (1 + alpha) * Wz - alpha * Wz_old
@@ -85,9 +85,13 @@ def fit(self, X, Y, **kwargs):
             gWs, gMs, Fs = self.gradVal_eval(Ws, Ms)
 
             in_it = 0
+            # for in_it in trange(2,file=sys.stdout, leave=False, unit_scale=True, desc='inner loop'):
             for in_it in trange(1000,file=sys.stdout, leave=False, unit_scale=True, desc='inner loop'):
                 Wzp = Ws - gWs/gamma
                 Mzp, Mzp_Pz, Mzp_DiagSigz = self.singular_projection (Ms - gMs/gamma, self.k)
+                # print(Mzp)
+                # print(Mzp_Pz)
+                # print(Mzp_DiagSigz)
                 Fzp = self.funVal_eval(Wzp, Mzp_Pz, Mzp_DiagSigz)
 
                 delta_Wzs = Wzp - Ws
@@ -147,7 +151,10 @@ def singular_projection (self, Msp, k):
             [type]: [description]
         """
         # l2.1 norm projection.
-        EValue, EVector = linalg.eig(Msp) 
+        EValue, EVector = LA.eig(Msp) 
+        idx = EValue.argsort()   
+        EValue = EValue[idx]
+        EVector = EVector[:,idx]
         Pz = np.real(EVector)
         diag_EValue = np.real(EValue)
         DiagSigz, _, _ = self.bsa_ihb(diag_EValue, np.ones(diag_EValue.shape), k, np.ones(diag_EValue.shape))
@@ -224,7 +231,6 @@ def gradVal_eval(self, W, M):
             grad_W = grad_W + 2 * self.c * invEtaMWt.T
             W2 = W.T @ W
             grad_M = - self.c * W2@linalg.inv(IM)@linalg.inv(IM)
-            
         funcVal = 0
         if self.opts.pFlag:
             pass
@@ -252,15 +258,19 @@ def funVal_eval(self, W, M_Pz, M_DiagSigz):
     def get_params(self, deep = False):
         return {'rho1':self.rho1, 'rho2':self.rho2,'opts':self.opts, 'k':self.k}
 
+    def get_weights(self):
+        return self.W
+    
     def analyse(self):
         # returns correlation matrix
 
-        # kmCMTL_OrderedModel = np.zeros(self.W.shape)
-        # for i in range(self.k):
-        #     clusModel = self.W[:, i:self.task_num*self.k:self.k]
-        #     kmCMTL_OrderedModel[:, (i)*self.task_num: (i+1)* self.task_num] = clusModel
-        # return 1-np.corrcoef(kmCMTL_OrderedModel)
-        return self.W
+        kmCMTL_OrderedModel = np.zeros(self.W.shape)
+        clus_task_num = self.task_num//self.k
+        for i in range(self.k):
+            clusModel = self.W[:, i:self.task_num:self.k]
+            kmCMTL_OrderedModel[:, (i)*clus_task_num: (i+1)* clus_task_num] = clusModel
+        return 1-np.corrcoef(kmCMTL_OrderedModel)
+        # return self.W
 
 
 

Vampyr_MTL/functions/tests/test_C_Least_L21.py

@@ -76,24 +76,59 @@ def test_bsa_ihb(self):
         assert np.isnan(t_star) == True
         assert it == 3
     def test_basic_mat(self):
-        clf = MTL_Cluster_Least_L21(opts, 3)
+        clus_num = 2
+        clus_task_num = 10
+        task_num = clus_num * clus_task_num
+        clf = MTL_Cluster_Least_L21(opts, 2)
         clf.fit(X, Y)
         corr = clf.analyse()
         # print(corr)
-        fig = px.imshow(corr)
-        fig2 = px.imshow(W)
+        fig = px.imshow(corr, color_continuous_scale='Bluered_r')
         fig.update_layout(
         title={
             'text': "predict",
             })
         fig.show()
+        OrderedTrueModel = np.zeros(W.shape)
+        clus_task_num = task_num//clus_num
+        for i in range(clus_num):
+            clusModel = W[:, i:task_num:clus_num]
+            OrderedTrueModel[:, (i)*clus_task_num: (i+1)* clus_task_num] = clusModel
+        corr2 = 1-np.corrcoef(OrderedTrueModel)
+        fig2 = px.imshow(corr2, color_continuous_scale='Bluered_r')
         fig2.update_layout(
         title={
             'text': "real",
             })
         fig2.show()
 
-    
+    def test_check_simplified(self):
+        # generate cluster model
+        cluster_weight = np.ones((dimension, clus_num))* clus_var
+        W = np.tile(cluster_weight, (1, clus_task_num))
+        cluster_index = np.tile(range(clus_num), (1, clus_task_num)).T
+
+        # generate task and intra-cluster variance
+        W_it = np.zeros((dimension, task_num)) * task_var
+        for i in range(task_num):
+            bll = np.hstack(((W[:-1-comm_dim+1,i]==0).reshape(1,-1), np.zeros((1,comm_dim))==1))
+            W_it[:,i][bll.flatten()]=0
+        W = W+W_it
+
+        W = W + np.zeros((dimension, task_num))*nois_var
+
+        X = [0]*task_num
+        Y = [0]*task_num
+        for i in range(task_num):
+            X[i] = np.ones((sample_size, dimension))
+            xw = X[i] @ W[:,i]
+            s= xw.shape
+            xw = xw + np.ones((s[0])) * nois_var
+            Y[i] = np.sign(xw)
+
+        clf = MTL_Cluster_Least_L21(opts, 2)
+        clf.fit(X, Y)
+        corr = clf.analyse()
     # def test_iris_accuracy(self):
     #     clf = MTL_Cluster_Least_L21(opts, 3)
     #     clf.fit(X_train, Y_train)