new code

Author: js05212

Real/configs/config_cub_18.py

@@ -0,0 +1,108 @@
+from easydict import EasyDict
+import numpy as np
+import pickle
+
+
+def read_pickle(name):
+    with open(name, "rb") as f:
+        data = pickle.load(f)
+    return data
+
+
+# load/output dir
+opt = EasyDict()
+opt.loadf = "./dump"
+opt.outf = "./dump"
+opt.outr = './data/test result'
+
+# normalize each data domain
+# opt.normalize_domain = False
+opt.print_switch = True
+opt.adj_default = True
+# now it is half circle
+opt.num_domain = 18
+opt.full_domain = list(range(opt.num_domain))
+opt.src_domain = [0,1,2,3,4,5,6,7,8] # [0,1,2,3,10,11,12,13]
+opt.tgt_domain = list(set(opt.full_domain) - set(opt.src_domain))
+opt.num_source = len(opt.src_domain)
+opt.num_target = opt.num_domain - opt.num_source
+opt.src_dmn_num = opt.num_source
+opt.tgt_dmn_num = opt.num_target
+opt.all_domain = opt.src_domain + opt.tgt_domain
+
+opt.test_on_all_dmn = True
+
+opt.sample_neighbour = False
+
+
+#opt.model = "DANN"
+#opt.model = "CDANN"
+#opt.model = "ADDA"
+opt.model = 'TSDA'
+#opt.model = "GDA"
+opt.cond_disc = (
+    False  # whether use conditional discriminator or not (for CDANN)
+)
+
+
+opt.use_visdom = False
+opt.visdom_port = 2000
+
+opt.use_g_encode = False # False  # True
+if opt.use_g_encode:
+    opt.g_encode = read_pickle("g_encode_l7l40.pkl")
+
+
+opt.device = "cuda"
+opt.seed = 2333  # 1# 101 # 1 # 233 # 1
+
+# opt.lambda_gan = 0.5  # 0.5 # 0.3125 # 0.5 # 0.5
+opt.lambda_gan = 0
+
+# for MDD use only
+opt.lambda_src = 0.5
+opt.lambda_tgt = 0.5
+
+# for TDDA use only
+opt.lambda_r = 0.594795294351678
+opt.lambda_d = 0.5
+opt.lambda_e = 0.7786359421472335
+opt.lambda_c = 1
+opt.num_epoch = 300
+opt.batch_size = 5
+opt.lr_d = 1e-5 # 3e-5 # 1e-4 # 2.9 * 1e-5 #3e-5  # 1e-4
+opt.lr_e = 1e-5  # 3e-5 # 1e-4 # 2.9 * 4e-6
+opt.lr_g = 1e-4
+opt.lr_r = 1e-4
+opt.gamma = 100
+opt.beta1 = 0.9
+opt.weight_decay = 5e-4
+opt.wgan = False  # do not use wgan to train
+opt.no_bn = True  # do not use batch normalization # True
+
+# model size configs, used for D, E, F
+opt.nt = 2  # dimension of the vertex embedding
+opt.nc = 2  # number of label class
+opt.nd_out = 2  # dimension of D's output
+opt.nr_out = 2
+opt.num_input = 4096    # the x data dimension
+opt.nh = 4096        # TODO: the hidden states for many modules, be careful
+opt.nv_embed = 2     # the vertex embedding dimension
+# sample how many vertices for training R
+opt.sample_v = opt.num_domain
+
+# # sample how many vertices for training G
+opt.sample_v_g = opt.num_domain
+
+opt.test_interval = 20
+opt.save_interval = 100
+# drop out rate
+opt.p = 0.2
+opt.shuffle = True
+
+
+# dataset
+opt.data_src = "data/"
+opt.data_path = opt.data_src + "feature_upperparts_black.pkl"
+opt.dataset = opt.data_path
+opt.A = read_pickle(opt.data_src + "A_cub_18.pkl")

Real/configs/config_imagenet_11.py

@@ -0,0 +1,110 @@
+from easydict import EasyDict
+import numpy as np
+import pickle
+
+
+def read_pickle(name):
+    with open(name, "rb") as f:
+        data = pickle.load(f)
+    return data
+
+
+# load/output dir
+opt = EasyDict()
+opt.loadf = "./dump"
+opt.outf = "./dump"
+opt.outr = './data/test result'
+
+# normalize each data domain
+# opt.normalize_domain = False
+opt.print_switch = True
+opt.adj_default = True
+# now it is half circle
+opt.num_domain = 11
+opt.full_domain = list(range(opt.num_domain))
+opt.src_domain = [6,7,8,9,10]
+opt.tgt_domain = list(set(opt.full_domain) - set(opt.src_domain))
+opt.num_source = len(opt.src_domain)
+opt.num_target = opt.num_domain - opt.num_source
+opt.src_dmn_num = opt.num_source
+opt.tgt_dmn_num = opt.num_target
+opt.all_domain = opt.src_domain + opt.tgt_domain
+
+opt.test_on_all_dmn = True
+
+opt.sample_neighbour = False
+
+
+#opt.model = "DANN"
+#opt.model = "CDANN"
+#opt.model = "ADDA"
+opt.model = 'TSDA'
+#opt.model = "GDA"
+opt.cond_disc = (
+    False  # whether use conditional discriminator or not (for CDANN)
+)
+
+
+opt.use_visdom = False
+opt.visdom_port = 2000
+
+opt.use_g_encode = False # False  # True
+if opt.use_g_encode:
+    opt.g_encode = read_pickle("g_encode_l7l40.pkl")
+
+
+opt.device = "cuda"
+opt.seed = 2333  # 1# 101 # 1 # 233 # 1
+
+# opt.lambda_gan = 0.5  # 0.5 # 0.3125 # 0.5 # 0.5
+opt.lambda_gan = 0
+
+# for MDD use only
+opt.lambda_src = 0.5
+opt.lambda_tgt = 0.5
+
+# for TDDA use only
+opt.lambda_r = 0.594795294351678
+opt.lambda_d = 0.2488505602149487
+opt.lambda_e = 0.7786359421472335
+opt.lambda_c = 1
+
+opt.num_epoch = 300
+opt.batch_size = 5
+opt.lr_d = 1e-5 # 3e-5 # 1e-4 # 2.9 * 1e-5 #3e-5  # 1e-4
+opt.lr_e = 1e-5  # 3e-5 # 1e-4 # 2.9 * 4e-6
+opt.lr_g = 1e-4
+opt.lr_r = 1e-4
+opt.gamma = 100
+opt.beta1 = 0.9
+opt.weight_decay = 5e-4
+opt.wgan = False  # do not use wgan to train
+opt.no_bn = True  # do not use batch normalization # True
+
+# model size configs, used for D, E, F
+opt.nt = 2  # dimension of the vertex embedding
+opt.nc = 2  # number of label class
+opt.nd_out = 2  # dimension of D's output
+opt.nr_out = 2
+opt.num_input = 4096    # the x data dimension
+opt.nh = 4096        # TODO: the hidden states for many modules, be careful
+opt.nv_embed = 2     # the vertex embedding dimension
+# sample how many vertices for training R
+opt.sample_v = opt.num_domain
+
+# # sample how many vertices for training G
+opt.sample_v_g = opt.num_domain
+
+opt.test_interval = 20
+opt.save_interval = 100
+# drop out rate
+opt.p = 0.2
+opt.shuffle = True
+
+
+# dataset
+opt.data_src = "data/"
+opt.data_path = opt.data_src + "feature_brown.pkl"
+opt.dataset = opt.data_path
+opt.A_root = read_pickle(opt.data_src + "A_brown_root.pkl")
+opt.A = read_pickle(opt.data_src + "A_brown.pkl")

Real/data/A_brown.pkl

@@ -0,0 +1,50 @@
+import numpy as np
+from torch.utils.data import Dataset
+import pickle
+
+
+def read_pickle(name):
+    with open(name, "rb") as f:
+        data = pickle.load(f)
+    return data
+
+
+def write_pickle(data, name):
+    with open(name, "wb") as f:
+        pickle.dump(data, f)
+
+
+class ToyDataset(Dataset):
+    def __init__(self, pkl, domain_id, opt=None):
+        idx = pkl["domain"] == domain_id
+        self.data = pkl["data"][idx].astype(np.float32)
+        self.label = pkl["label"][idx].astype(np.int64)
+        self.domain = domain_id
+
+        # if opt.normalize_domain:
+        #     print('===> Normalize in every domain')
+        #     self.data_m, self.data_s = self.data.mean(0, keepdims=True), self.data.std(0, keepdims=True)
+        #     self.data = (self.data - self.data_m) / self.data_s
+
+    def __getitem__(self, idx):
+        return self.data[idx], self.label[idx], self.domain
+
+    def __len__(self):
+        return len(self.data)
+
+
+class SeqToyDataset(Dataset):
+    def __init__(self, datasets, size=3 * 200):
+        self.datasets = datasets
+        self.size = size
+        print(
+            "SeqDataset Size {} Sub Size {}".format(
+                size, [len(ds) for ds in datasets]
+            )
+        )
+
+    def __len__(self):
+        return self.size
+
+    def __getitem__(self, i):
+        return [ds[i] for ds in self.datasets]

Real/data/A_brown_grda.pkl

@@ -0,0 +1,122 @@
+import numpy as np
+from torch.utils.data import DataLoader, Dataset
+import pickle
+
+
+def read_pickle(name):
+    with open(name, 'rb') as f:
+        data = pickle.load(f)
+    return data
+
+
+class FeatureDataset(Dataset):
+    def __init__(self, pkl, domain_id, sudo_len, opt=None):
+        idx = pkl['domain'] == domain_id
+        self.data = pkl['data'][idx].astype(np.float32)
+        self.label = pkl['label'][idx].astype(np.int64)
+        self.domain = domain_id
+        self.real_len = len(self.data)
+        self.sudo_len = sudo_len
+
+        # if opt.normalize_domain:
+        #     print('===> Normalize in every domain')
+        #     self.data_m, self.data_s = self.data.mean(0, keepdims=True), self.data.std(0, keepdims=True)
+        #     self.data = (self.data - self.data_m) / self.data_s
+
+    def __getitem__(self, idx):
+        idx %= self.real_len
+        return self.data[idx], self.label[idx], self.domain
+
+    def __len__(self):
+        # return len(self.data)
+        return self.sudo_len
+
+
+class FeatureDataloader(DataLoader):
+    def __init__(self, opt):
+        self.opt = opt
+        self.src_domain = opt.src_domain
+        self.tgt_domain = opt.tgt_domain
+        self.all_domain = opt.all_domain
+
+        self.pkl = read_pickle(opt.data_path)
+        sudo_len = 0
+        for i in self.all_domain:
+            idx = self.pkl['domain'] == i
+            sudo_len = max(sudo_len, idx.sum())
+        self.sudo_len = sudo_len
+
+        print("sudo len: {}".format(sudo_len))
+
+        self.train_datasets = [
+            FeatureDataset(
+                self.pkl,
+                domain_id=i,
+                opt=opt,
+                sudo_len=self.sudo_len,
+            ) for i in self.all_domain
+        ]
+
+        if self.opt.test_on_all_dmn:
+            self.test_datasets = [
+                FeatureDataset(
+                    self.pkl,
+                    domain_id=i,
+                    opt=opt,
+                    sudo_len=self.sudo_len,
+                ) for i in self.all_domain
+            ]
+        else:
+            self.test_datasets = [
+                FeatureDataset(
+                    self.pkl,
+                    domain_id=i,
+                    opt=opt,
+                    sudo_len=self.sudo_len,
+                ) for i in self.tgt_domain
+            ]
+
+        self.train_data_loader = [
+            DataLoader(dataset,
+                       batch_size=opt.batch_size,
+                       shuffle=opt.shuffle,
+                       # consider if necessary
+                       num_workers=0,
+                       pin_memory=True,
+                       #persistent_workers=True
+                       )
+            for dataset in self.train_datasets
+        ]
+
+        self.test_data_loader = [
+            DataLoader(dataset,
+                       batch_size=opt.batch_size,
+                       shuffle=opt.shuffle,
+                       num_workers=0,
+                       pin_memory=True,
+                       #persistent_workers=True
+                       )
+            for dataset in self.test_datasets
+        ]
+
+    def get_train_data(self):
+        # this is return a iterator for the whole dataset
+        return zip(*self.train_data_loader)
+
+    def get_test_data(self):
+        return zip(*self.test_data_loader)
+
+# class SeqToyDataset(Dataset):
+#     # the size may change because of the toy dataset!!
+#     def __init__(self, datasets, size=3 * 200):
+#         self.datasets = datasets
+#         self.size = size
+#         print('SeqDataset Size {} Sub Size {}'.format(
+#             size, [len(ds) for ds in datasets]
+#         ))
+
+#     def __len__(self):
+#         return self.size
+
+#     def __getitem__(self, i):
+#         return [ds[i] for ds in self.datasets]