some code related to msda representation experiments

experiments_amazon.py

@@ -1,5 +1,6 @@
 import numpy as np
 from DANN import DANN
+from mSDA import compute_msda_representation
 from sklearn.datasets import load_svmlight_files
 from sklearn import svm
 
@@ -9,15 +10,33 @@ def main():
     source_name = 'dvd'         # source domain: books, dvd, kitchen, or electronics
     target_name = 'electronics' # traget domain: books, dvd, kitchen, or electronics
     adversarial = False          # set to False to learn a standard NN
+    msda = True
 
     hidden_layer_size = 50
     lambda_adapt = 0.1 if adversarial else 0.
-    learning_rate = 0.001
+    learning_rate = 0.001 if not msda else 0.0001
     maxiter = 200
 
     print("Loading data...")
     xs, ys, xt, _, xtest, ytest = load_amazon(source_name, target_name, data_folder, verbose=True)
 
+    if msda:
+        xs_path, xt_path, xtest_path = ['%s/%s.%s_%s_msda.npy' % (data_folder, source_name, target_name, E)
+                                        for E in ('source', 'target', 'test')]
+        try:
+            xs_msda = np.load(xs_path)
+            xt_msda = np.load(xt_path)
+            xtest_msda = np.load(xtest_path)
+            print('mSDA representations loaded from disk')
+        except:
+            print('Computing mSDA representations...')
+            xs_msda, xt_msda, xtest_msda = compute_msda_representation(xs, xt, xtest)
+            np.save(xs_path, xs_msda)
+            np.save(xt_path, xt_msda)
+            np.save(xtest_path, xtest_msda)
+
+        xs, xt, xtest = xs_msda, xt_msda, xtest_msda
+
     nb_valid = int(0.1 * len(ys))
     xv, yv = xs[-nb_valid:, :], ys[-nb_valid:]
     xs, ys = xs[0:-nb_valid, :], ys[0:-nb_valid]

mSDA.py

@@ -1,6 +1,17 @@
 import numpy as np
 
-def mDA(X, noise, eta):
+
+def compute_msda_representation(x_source, x_target, x_test):
+    nb_souce = np.shape(x_source)[0]
+    x_train = np.vstack((x_source, x_target))
+    new_x_train, W = msda_fit(x_train.T)
+    mew_x_source = new_x_train[:,:nb_souce].T
+    new_x_target = new_x_train[:,nb_souce:].T
+    new_x_test = msda_forward(x_test.T, W).T
+    return mew_x_source, new_x_target, new_x_test
+
+
+def mda_fit(X, noise=0.5, eta=1e-5):
     """
     inputs: 
         X : d x n input (Transpose of the usual data-matrix)
@@ -33,13 +44,13 @@ def mDA(X, noise, eta):
     # final W = P*Q^-1, dx(d+1)
     reg = eta * np.eye(d+1)
     reg[-1,-1] = 0
-    W = np.linalg.solve( Q.T+reg, P.T ).T
+    W = np.linalg.solve(Q.T + reg, P.T).T
 
-    hx = np.tanh( np.dot(W, Xb) )
+    hx = np.tanh(np.dot(W, Xb))
     return hx, W
 
 
-def mSDA(X, noise, nb_layers, verbose=False):
+def msda_fit(X, noise=0.5, nb_layers=5, verbose=False):
     """
     inputs:
         X : d x n input Transpose of the usual data-matrix)
@@ -57,15 +68,15 @@ def mSDA(X, noise, nb_layers, verbose=False):
 
     for i in range(nb_layers):
         if verbose: print('layer =', i)
-        newhx, W = mDA(prevhx, noise, eta)
+        newhx, W = mda_fit(prevhx, noise, eta)
         W_list.append(W)
         allhx = np.vstack((allhx, newhx))
         prevhx = newhx
 
     return allhx, W_list
 
 
-def mSDA_forward(X, W_list):
+def msda_forward(X, W_list):
     """
     inputs: 
         X : d x n input (Transpose of the usual data-matrix)