changes for AMIA

Author: DaPraxis

.pypirc

@@ -1,8 +1,9 @@
 [distutils]
-    index-servers=
-        testpypi
+index-servers =
+    pypi
+    testpypi
 
-    [testpypi]
-    repository: https://test.pypi.org/simple/Vampyr-MTL-Max-JJ
-    username: Max_JJ
-    password: Haoyan13911233286
+[testpypi]
+repository: https://test.pypi.org/simple/Vampyr-MTL-Max-JJ
+username: Max_JJ
+password: Haoyan13911233286

Vampyr_MTL/evaluations/utils.py

@@ -1,6 +1,8 @@
 from sklearn.model_selection import train_test_split
 import numpy as np
 import pandas as pd
+from collections import defaultdict, OrderedDict
+import plotly.figure_factory as ff
 
 class opts:
 	def __init__(self, maxIter, init):
@@ -48,3 +50,74 @@ def MTL_data_extract(df, task_feat, target):
 		y = tmp1.loc[:, df.columns == target].values
 		Y.append(np.array(y))
 	return X, Y
+
+def RFA(df, task, target, top=10):
+    def reformat(cols, w, top=10):
+     	# Task -> coln
+      	RFA = OrderedDict()
+      	cols = np.array(cols)
+    	fet, task = w.shape
+    	total = {}
+    	all_tasks = []
+    	for i in range(task):
+         	col = w[:,i].flatten()
+         	index = sorted(range(len(col)), key=lambda i: col[i], reverse=True)[:top]
+   			e = set(cols[index])
+   			RFA["task {}".format(i+1)] = e
+   			all_tasks.append("task {}".format(i+1))
+   			total = set.union(e, total)
+   		print("all top {} colns are {}".format(top, total))
+  		# Coln -> tasks
+  		ret = defaultdict(lambda: [])
+  		# dataframe to visualize
+  		df_v = pd.DataFrame(False, index=list(total), columns=all_tasks)
+  		df_v2 = pd.DataFrame(None, index = list(total), columns=[str(p+1) for p in range(len(all_tasks))])
+  		df_RFA = []
+  		for t in all_tasks:
+      		df_RFA.append(list(RFA[t]))
+   		for i in total:
+			count = 1
+			for k, v in RFA.items():
+       			if i in v:
+              		ret[i].append(k)
+					df_v[k][i]=True
+					df_v2[str(count)][i] = int(k[-2:])
+					if(len(k)==6):
+						df_v2[str(count)][i] = int(k[-1])
+					count+=1
+		return df_v, all_tasks, list(total), df_v2, df_RFA, RFA
+ 
+	def sort_df(df):
+		fet, tsk = df.values.shape
+		ret = pd.DataFrame(None, columns=list(df.columns))
+		ind = list(df.index)
+		seq = []
+		for i in range(tsk):
+			for j in range(fet):
+			if(np.count_nonzero(~np.isnan(list(df_v2.iloc[j].values)))==i+1):
+				ret.loc[len(ret)] = df_v2.iloc[j].values
+				seq.append(ind[j])
+		ret = ret.rename(index={i:j for i,j in zip(range(fet), seq)})
+		return ret
+
+	
+	def get_z_text(z, mp):
+		x, y = z.shape
+		ret = np.empty([x, y],dtype="S10")
+		for i in range(x):
+			for j in range(y):
+			ret[i][j]=mp[z[i][j]]
+		return ret.astype(str).tolist()
+ 
+ 	all_col = (df.loc[:, (df.columns != target)&(df.columns != tasks)].columns).tolist()
+	df_v, all_tasks, total, df_v2, RFA, index = reformat(all_col, mtl_clf.W, top=top)
+ 
+ 	mp = {i+1:"Task_{}".format(i) for i in range(len(X))}
+	mp[None] = ''
+	mp[np.nan] = ''
+	df_v3 = sort_df(df_v2)
+	z_text = get_z_text(df_v3.values, mp)
+	fig = ff.create_annotated_heatmap(z = df_v3.values.tolist(), annotation_text=z_text, y=list(df_v3.index))
+	fig.update_xaxes(showticklabels=False, showgrid=False)
+	return fig
+	

Vampyr_MTL/functions/MTL_Cluster_Least_L21.py

@@ -93,7 +93,7 @@ def fit(self, X, Y, **kwargs):
         gamma = 1.0
         gamma_inc = 2
 
-        for it in trange(self.opts.maxIter, file=sys.stdout, desc='outer loop'):
+        for it in trange(self.opts.maxIter, file=sys.stdout, desc='Training'):
             alpha = (t_old - 1)/t
             Ws = (1 + alpha) * Wz - alpha * Wz_old
             if(isspmatrix(Mz)):
@@ -106,7 +106,7 @@ def fit(self, X, Y, **kwargs):
 
             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'):
+            while True:
                 Wzp = Ws - gWs/gamma
                 Mzp, Mzp_Pz, Mzp_DiagSigz = self.singular_projection (Ms - gMs/gamma, self.k)
                 Fzp = self.funVal_eval(Wzp, Mzp_Pz, Mzp_DiagSigz)

Vampyr_MTL/functions/MTL_Least_L21.py

@@ -79,15 +79,15 @@ def fit(self, X, Y, **kwargs):
 		gamma = 1
 		gamma_inc = 2
 
-		for it in trange(self.opts.maxIter, file=sys.stdout, desc='outer loop'):
+		for it in trange(self.opts.maxIter, file=sys.stdout, desc='Training'):
 			alpha = (t_old - 1)/t
 			Ws = (1 + alpha) * Wz - alpha * Wz_old
 			# compute function value and gradients of the search point
 			gWs = self.gradVal_eval(Ws)
 			Fs = self.funVal_eval(Ws)
 			in_it = 0
 
-			for in_it in trange(1000,file=sys.stdout, leave=False, unit_scale=True, desc='inner loop'):
+			while True:
 				Wzp = self.FGLasso_projection(Ws - gWs/gamma, self.rho1 / gamma)
 				Fzp = self.funVal_eval(Wzp)
 				delta_Wzp = Wzp - Ws

Vampyr_MTL/functions/MTL_Logistic_L21.py

@@ -99,15 +99,15 @@ def fit(self, X, Y, **kwargs):
 		gamma = 1
 		gamma_inc = 2
 
-		for it in trange(self.opts.maxIter, file=sys.stdout, desc='outer loop'):
+		for it in trange(self.opts.maxIter, file=sys.stdout, desc='Training'):
 			alpha = (t_old - 1)/t
 
 			Ws = (1 + alpha) * Wz - alpha * Wz_old
 			Cs = (1 + alpha) * Cz - alpha * Cz_old
 
 			gWs, gCs, Fs = self.gradVal_eval(Ws, Cs)
 
-			for in_it in trange(1000,file=sys.stdout, leave=False, unit_scale=True, desc='inner loop'):
+			while True:
 				Wzp = self.FGLasso_projection(Ws - gWs/gamma, self.rho1 / gamma)
 				Czp = Cs - gCs/gamma
 				Fzp = self.funVal_eval(Wzp, Czp)

Vampyr_MTL/functions/MTL_Softmax_L21.py

@@ -136,15 +136,15 @@ def fit(self, X, Y, **kwargs):
 		gamma = 1
 		gamma_inc = 2
 
-		for it in trange(self.opts.maxIter, file=sys.stdout, desc='outer loop'):
+		for it in trange(self.opts.maxIter, file=sys.stdout, desc='Training'):
 			alpha = (t_old - 1)/t
 
 			Ws = (1 + alpha) * Wz - alpha * Wz_old
 			Cs = (1 + alpha) * Cz - alpha * Cz_old
 
 			gWs, gCs, Fs = self.gradVal_eval(Ws, Cs)
 
-			for in_it in trange(1000,file=sys.stdout, leave=False, unit_scale=True, desc='inner loop'):
+			while True:
 				Wzp = self.FGLasso_projection(Ws - gWs/gamma, self.rho1 / gamma)
 				Czp = Cs - gCs/gamma
 				Fzp = self.funVal_eval(Wzp, Czp)
@@ -156,7 +156,7 @@ def fit(self, X, Y, **kwargs):
 				r_sum = (nrm_delta_Czp + nrm_delta_Wzp)/2
 
 				Fzp_gamma = Fs + np.sum(delta_Wzp*gWs) + np.sum(delta_Czp*gCs)+ gamma/2 * r_sum*2
-				if (r_sum <=1e-20):
+				if (r_sum <=1e-28):
 					bFlag=1 # this shows that, the gradient step makes little improvement
 					break
 				if (Fzp <= Fzp_gamma):
@@ -178,19 +178,23 @@ def fit(self, X, Y, **kwargs):
 			if(self.opts.tFlag == 0):
 				if it>=2:
 					if (abs( funcVal[-1] - funcVal[-2]) <= self.opts.tol):
+						print("Terminate 0")
 						break
 
 			elif(self.opts.tFlag == 1):
 				if it>=2:
 					if (abs( funcVal[-1] - funcVal[-2] ) <= self.opts.tol* funcVal[-2]):
+						print("Terminate 1")
 						break
 
 			elif(self.opts.tFlag == 2):
 				if ( funcVal[-1]<= self.opts.tol):
+					print("Terminate 2")
 					break
 
 			elif(self.opts.tFlag == 3):
 				if it>=self.opts.maxIter:
+					print("Terminate 3")
 					break
 
 			t_old = t
@@ -322,7 +326,7 @@ def unit_funcVal_eval(self, w, c, task_idx):
 		weight = np.ones((1, self.Y[task_idx].shape[0]))/self.task_num
 		z = -self.Y[task_idx]*(np.transpose(self.X[task_idx])@w + c)
 		hinge = np.maximum(z, 0)
-		funcVal = np.sum(weight @ (np.log(np.exp(-hinge)+np.exp(z-hinge))+hinge))
+		funcVal = np.sum(weight @ (np.log(np.exp((-hinge).astype(np.float))+np.exp((z-hinge).astype(np.float)))+hinge))
 		return funcVal
 
 	def get_params(self, deep = False):

Vampyr_MTL/functions/init_opts.py

@@ -8,7 +8,7 @@ def init_opts(opts):
 
 	# Default values
 	DEFAULT_MAX_ITERATION = 1000
-	DEFAULT_TOLERANCE     = 1e-4
+	DEFAULT_TOLERANCE     = 1e-10
 	MINIMUM_TOLERANCE     = eps * 100
 	DEFAULT_TERMINATION_COND = 1
 	DEFAULT_INIT = 0

Vampyr_MTL/functions/tests/test_softmax_L21_hinge.py

@@ -2,14 +2,11 @@
 import numpy as np
 import pandas as pd
 from sklearn import datasets
+from sklearn import preprocessing
 from ...evaluations.utils import MTL_data_extract, MTL_data_split, opts
 from .test_data import get_data
-
-# class opts:
-# 	def __init__(self, maxIter, init):
-# 		self.maxIter = maxIter
-# 		self.init = init
-# 		self.pFlag = False
+from sklearn.linear_model import LogisticRegression
+import os
 
 opts = opts(1000,2)
 
@@ -22,8 +19,53 @@
 X_i, Y_i = MTL_data_extract(df2, 'cat2', 'target')
 X_train_c, X_test_c, Y_train_c, Y_test_c = MTL_data_split(X_i, Y_i, test_size=0.4)
 
+print(os.getcwd())
+print('???????????????')
+df3 = pd.read_csv('./cleaned_BRFSS.csv')
+
+def normalize(X):
+    for i in range(len(X)):
+        min_max_scaler = preprocessing.MinMaxScaler()
+        X[i] = min_max_scaler.fit_transform(X[i])
+    return X
 
 class Test_softmax_classification(object):
+    def test_real_data(self):
+        df4 = df3[(df3['ADDEPEV2']==2)|(df3['ADDEPEV2']==1)]
+        # opts.tol = 1e-20
+        X, Y = MTL_data_extract(df4, "ADDEPEV2", "_BMI5CAT")
+        task = [0]*2
+        taskT = 0
+        for i in range(1):
+            X_train, X_test, Y_train, Y_test = MTL_data_split(X, Y, test_size=0.998)
+            X_train = normalize(X_train)
+            X_test = normalize(X_test)
+            for i in range(len(Y_train)):
+                Y_train[i] = Y_train[i].astype(int)
+            clf = MTL_Softmax_L21(opts)
+            clf.fit(X_train, Y_train)
+            pred = clf.predict(X_test)
+            
+            c_t = 0
+            total = 0
+            for i in range(len(pred)):
+                correct = np.sum(pred[i]==Y_test[i])
+                sub = len(pred[i])
+                task[i] = max(task[i], correct/sub*100)
+                total += sub
+                c_t += correct
+            taskT = max(taskT, c_t/total*100)
+        print("accurcy for task 1 is {}%".format(task[0]))
+        print("accurcy for task 2 is {}%".format(task[1]))
+        print("total accuracy is {}%".format(taskT))
+        
+        for i in range(len(pred)):
+            clf = LogisticRegression(random_state=0).fit(X_train[i], Y_train[i])
+            s = clf.score(X_test[i], Y_test[i])
+            print("SKLearn accuracy for task {} is {}%".format(i, s*100))
+    
+        assert c_t/total*100 == 0
+    
     def test_soft_numerical_accuracy(self):
         ult_thres = 0.5
         thres = 0.9