first

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.tar.gz filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,3 +1,29 @@
----
-license: apache-2.0
----
+# Training Dynamic
+demo data store in /training_dynamic
+# evaluate subject model
+
+```
+conda activate myvenv
+python subject_model_eval.py
+```
+The trainig dynamic performance will be store in /training_dynamic/Model/subject_model_eval.json
+
+
+# Run trustvis 
+```
+
+conda activate deepdebugger
+# proxy only
+python porxy.py --epoch 1/2/3 (default 3)
+
+the vis result will be store in /training_dynamic/Proxy/***.png
+the evaluation resulte wiil be store in /training_dynamic/Model/proxy_eval.json
+
+# trustvis with AL
+python active_learning.py  --epoch 1/2/3 (default 3)
+
+the vis result will be store in /training_dynamic/Trust_al/***.png
+
+the evaluation resulte wiil be store in /training_dynamic/Model/trustvis_al_eval.json
+
+```

active_learning.py

@@ -0,0 +1,243 @@
+########################################################################################################################
+#                                                          IMPORT                                                      #
+########################################################################################################################
+import torch
+import sys
+import os
+import json
+import time
+import numpy as np
+import argparse
+
+from torch.utils.data import DataLoader
+from torch.utils.data import WeightedRandomSampler
+from umap.umap_ import find_ab_params
+
+from singleVis.custom_weighted_random_sampler import CustomWeightedRandomSampler
+from singleVis.SingleVisualizationModel import VisModel
+from singleVis.losses import UmapLoss, ReconstructionLoss, TemporalLoss, DVILoss, SingleVisLoss, DummyTemporalLoss
+from singleVis.edge_dataset import DVIDataHandler
+from singleVis.trainer import DVIALMODITrainer
+from singleVis.data import NormalDataProvider
+from singleVis.spatial_skeleton_edge_constructor import OriginSingleEpochSpatialEdgeConstructor, PredDistSingleEpochSpatialEdgeConstructor
+from singleVis.projector import DVIProjector
+from singleVis.eval.evaluator import Evaluator
+from singleVis.utils import find_neighbor_preserving_rate
+from singleVis.visualizer import visualizer
+from trustVis.skeleton_generator import CenterSkeletonGenerator
+########################################################################################################################
+#                                                    PARAMETERS                                                   #
+########################################################################################################################
+"""This serve as an example of DeepVisualInsight implementation in pytorch."""
+VIS_METHOD = "DVI" # DeepVisualInsight
+
+########################################################################################################################
+#                                                     LOAD PARAMETERS                                                  #
+########################################################################################################################
+parser = argparse.ArgumentParser(description='Process hyperparameters...')
+
+# get workspace dir
+current_path = os.getcwd()
+
+new_path = os.path.join(current_path, 'training_dynamic')
+
+parser.add_argument('--content_path', type=str,default=new_path)
+parser.add_argument('--base', type=str,default='proxy')
+parser.add_argument('--name', type=str,default='trustvis')
+parser.add_argument('--start', type=int,default=1)
+parser.add_argument('--end', type=int,default=3)
+parser.add_argument('--epoch', type=int,default=3)
+args = parser.parse_args()
+
+
+SAVED_NAME = args.name
+
+
+CONTENT_PATH = args.content_path
+sys.path.append(CONTENT_PATH)
+with open(os.path.join(CONTENT_PATH, "config.json"), "r") as f:
+    config = json.load(f)
+config = config[VIS_METHOD]
+
+
+SETTING = config["SETTING"]
+CLASSES = config["CLASSES"]
+DATASET = config["DATASET"]
+PREPROCESS = config["VISUALIZATION"]["PREPROCESS"]
+GPU_ID = config["GPU"]
+EPOCH_START = args.epoch
+EPOCH_END = args.epoch
+EPOCH_PERIOD = 1
+
+# Training parameter (subject model)
+TRAINING_PARAMETER = config["TRAINING"]
+NET = TRAINING_PARAMETER["NET"]
+LEN = TRAINING_PARAMETER["train_num"]
+
+# Training parameter (visualization model)
+VISUALIZATION_PARAMETER = config["VISUALIZATION"]
+LAMBDA1 = VISUALIZATION_PARAMETER["LAMBDA1"]
+LAMBDA2 = VISUALIZATION_PARAMETER["LAMBDA2"]
+B_N_EPOCHS = VISUALIZATION_PARAMETER["BOUNDARY"]["B_N_EPOCHS"]
+L_BOUND = VISUALIZATION_PARAMETER["BOUNDARY"]["L_BOUND"]
+ENCODER_DIMS = VISUALIZATION_PARAMETER["ENCODER_DIMS"]
+DECODER_DIMS = VISUALIZATION_PARAMETER["DECODER_DIMS"]
+S_N_EPOCHS = VISUALIZATION_PARAMETER["S_N_EPOCHS"]
+N_NEIGHBORS = VISUALIZATION_PARAMETER["N_NEIGHBORS"]
+PATIENT = VISUALIZATION_PARAMETER["PATIENT"]
+MAX_EPOCH = VISUALIZATION_PARAMETER["MAX_EPOCH"]
+
+VIS_MODEL_NAME = VISUALIZATION_PARAMETER["VIS_MODEL_NAME"]
+EVALUATION_NAME = VISUALIZATION_PARAMETER["EVALUATION_NAME"]
+
+# Define hyperparameters
+GPU_ID = 1
+DEVICE = torch.device("cuda:{}".format(GPU_ID) if torch.cuda.is_available() else "cpu")
+
+import Model.model as subject_model
+net = eval("subject_model.{}()".format(NET))
+
+########################################################################################################################
+#                                                    TRAINING SETTING                                                  #
+########################################################################################################################
+BASE_MODEL_NAME = args.base
+# PREPROCESS = 1
+# Define data_provider
+data_provider = NormalDataProvider(CONTENT_PATH, net, EPOCH_START, EPOCH_END, EPOCH_PERIOD, device=DEVICE, classes=CLASSES, epoch_name='Epoch', verbose=1)
+# if PREPROCESS:
+#     data_provider._meta_data()
+#     if B_N_EPOCHS >0:
+#         data_provider._estimate_boundary(LEN//10, l_bound=L_BOUND)
+
+# Define visualization models
+model = VisModel(ENCODER_DIMS, DECODER_DIMS)
+
+# Define Losses
+negative_sample_rate = 5
+min_dist = .1
+_a, _b = find_ab_params(1.0, min_dist)
+umap_loss_fn = UmapLoss(negative_sample_rate, DEVICE, _a, _b, repulsion_strength=1.0)
+recon_loss_fn = ReconstructionLoss(beta=1.0)
+single_loss_fn = SingleVisLoss(umap_loss_fn, recon_loss_fn, lambd=LAMBDA1)
+# Define Projector
+projector = DVIProjector(vis_model=model, content_path=CONTENT_PATH, vis_model_name=BASE_MODEL_NAME, device=DEVICE) # vis_model_name 一个初始的dvi
+
+start_flag = 1
+prev_model = VisModel(ENCODER_DIMS, DECODER_DIMS)
+
+for iteration in range(EPOCH_START, EPOCH_END+EPOCH_PERIOD, EPOCH_PERIOD):
+    # Define DVI Loss
+    if start_flag:
+        temporal_loss_fn = DummyTemporalLoss(DEVICE)
+        criterion = DVILoss(umap_loss_fn, recon_loss_fn, temporal_loss_fn, lambd1=LAMBDA1, lambd2=0.0, device=DEVICE)
+        start_flag = 0
+    else:
+        # TODO AL mode, redefine train_representation
+        prev_data = data_provider.train_representation(iteration-EPOCH_PERIOD)
+        curr_data = data_provider.train_representation(iteration)
+        npr = find_neighbor_preserving_rate(prev_data, curr_data, N_NEIGHBORS)
+        temporal_loss_fn = TemporalLoss(w_prev, DEVICE)
+        criterion = DVILoss(umap_loss_fn, recon_loss_fn, temporal_loss_fn, lambd1=LAMBDA1, lambd2=torch.from_numpy(LAMBDA2*npr), device=DEVICE)
+    
+    vis = visualizer(data_provider, projector, 200, "tab10")
+    grid_high, grid_emd ,border = vis.get_epoch_decision_view(iteration,400,None, True)
+    train_data_embedding = projector.batch_project(iteration, data_provider.train_representation(iteration))
+    from sklearn.neighbors import NearestNeighbors
+    import numpy as np
+
+    # 假设 train_data_embedding 和 grid_emd 都是 numpy arrays，每一行都是一个点
+    threshold = 5  # hyper-peremeter
+
+    # use train_data_embedding initialize NearestNeighbors 
+    nbrs = NearestNeighbors(n_neighbors=1, algorithm='ball_tree').fit(train_data_embedding)
+    # for each grid_emd，find train_data_embedding nearest sample
+    distances, indices = nbrs.kneighbors(grid_emd)
+    # filter by distance
+    mask = distances.ravel() < threshold
+    selected_indices = np.arange(grid_emd.shape[0])[mask]
+
+    grid_high_mask = grid_high[selected_indices]
+
+    skeleton_generator = CenterSkeletonGenerator(data_provider,iteration,0.5,500)
+    high_bom, high_rad = skeleton_generator.center_skeleton_genertaion()
+    print("number",len(high_bom))
+       
+    # Define training parameters
+    optimizer = torch.optim.Adam(model.parameters(), lr=.01, weight_decay=1e-5)
+    lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=4, gamma=.1)
+    # Define Edge dataset
+    t0 = time.time()
+    spatial_cons = OriginSingleEpochSpatialEdgeConstructor(data_provider, iteration, S_N_EPOCHS, B_N_EPOCHS, N_NEIGHBORS)
+    edge_to, edge_from, probs, feature_vectors, attention = spatial_cons.construct()
+    t1 = time.time()
+
+    probs = probs / (probs.max()+1e-3)
+    eliminate_zeros = probs> 1e-3    #1e-3
+    edge_to = edge_to[eliminate_zeros]
+    edge_from = edge_from[eliminate_zeros]
+    probs = probs[eliminate_zeros]
+    
+    dataset = DVIDataHandler(edge_to, edge_from, feature_vectors, attention)
+
+    n_samples = int(np.sum(S_N_EPOCHS * probs) // 1)
+    # chose sampler based on the number of dataset
+    if len(edge_to) > pow(2,24):
+        sampler = CustomWeightedRandomSampler(probs, n_samples, replacement=True)
+    else:
+        sampler = WeightedRandomSampler(probs, n_samples, replacement=True)
+    edge_loader = DataLoader(dataset, batch_size=2000, sampler=sampler, num_workers=8, prefetch_factor=10)
+
+    ########################################################################################################################
+    #                                                       TRAIN                                                          #
+    ########################################################################################################################
+    file_path = os.path.join(data_provider.content_path, "Model", "Epoch_{}".format(iteration), "{}.pth".format(BASE_MODEL_NAME))
+    save_model = torch.load(file_path, map_location="cpu")
+    model.load_state_dict(save_model["state_dict"])
+
+    trainer = DVIALMODITrainer(model, criterion, optimizer, lr_scheduler, edge_loader=edge_loader, DEVICE=DEVICE, grid_high_mask=grid_high_mask, high_bom=high_bom, high_rad=high_rad, iteration=iteration, data_provider=data_provider, prev_model=prev_model, S_N_EPOCHS=S_N_EPOCHS, B_N_EPOCHS=B_N_EPOCHS, N_NEIGHBORS=N_NEIGHBORS)
+
+    t2=time.time()
+    trainer.train(PATIENT, MAX_EPOCH)
+    t3 = time.time()
+
+    # save result
+    save_dir = data_provider.model_path
+    trainer.record_time(save_dir, "time_{}".format(VIS_MODEL_NAME), "complex_construction", str(iteration), t1-t0)
+    trainer.record_time(save_dir, "time_{}".format(VIS_MODEL_NAME), "training", str(iteration), t3-t2)
+    save_dir = os.path.join(data_provider.model_path, "Epoch_{}".format(iteration))
+    trainer.save(save_dir=save_dir, file_name="{}".format(SAVED_NAME))
+
+    print("Finish epoch {}...".format(iteration))
+
+    prev_model.load_state_dict(model.state_dict())
+    for param in prev_model.parameters():
+        param.requires_grad = False
+    w_prev = dict(prev_model.named_parameters())
+
+print('aaacccllll runtime', t3-t0)
+########################################################################################################################
+#                                                      VISUALIZATION                                                   #
+########################################################################################################################
+
+from singleVis.visualizer import visualizer
+
+vis = visualizer(data_provider, projector, 200, "tab10")
+save_dir = os.path.join(data_provider.content_path, "Trust_al")
+if not os.path.exists(save_dir):
+    os.mkdir(save_dir)
+for i in range(EPOCH_START, EPOCH_END+1, EPOCH_PERIOD):
+    vis.savefig(i, path=os.path.join(save_dir, "{}_{}_{}.png".format(VIS_MODEL_NAME, i, VIS_METHOD)))
+
+    
+########################################################################################################################
+#                                                       EVALUATION                                                     #
+########################################################################################################################
+
+evaluator = Evaluator(data_provider, projector)
+
+
+
+
+Evaluation_NAME = 'trustvis_al_eval'
+for i in range(EPOCH_START, EPOCH_END+1, EPOCH_PERIOD):
+    evaluator.save_epoch_eval(i, 15, temporal_k=5, file_name="{}".format(Evaluation_NAME))

proxy.py

@@ -0,0 +1,275 @@
+########################################################################################################################
+#                                                          IMPORT                                                      #
+########################################################################################################################
+import torch
+import sys
+import os
+import json
+import time
+import numpy as np
+import argparse
+
+from torch.utils.data import DataLoader
+from torch.utils.data import WeightedRandomSampler
+from umap.umap_ import find_ab_params
+
+from singleVis.custom_weighted_random_sampler import CustomWeightedRandomSampler
+from singleVis.SingleVisualizationModel import VisModel
+from singleVis.losses import UmapLoss, ReconstructionLoss, TemporalLoss, DVILoss, SingleVisLoss, DummyTemporalLoss
+from singleVis.edge_dataset import DVIDataHandler
+from singleVis.trainer import DVITrainer
+from singleVis.eval.evaluator import Evaluator
+from singleVis.data import NormalDataProvider
+# from singleVis.spatial_edge_constructor import SingleEpochSpatialEdgeConstructor
+from singleVis.spatial_skeleton_edge_constructor import ProxyBasedSpatialEdgeConstructor
+
+from singleVis.projector import DVIProjector
+from singleVis.utils import find_neighbor_preserving_rate
+
+from trustVis.skeleton_generator import CenterSkeletonGenerator
+########################################################################################################################
+#                                                     DVI PARAMETERS                                                   #
+########################################################################################################################
+"""This serve as an example of DeepVisualInsight implementation in pytorch."""
+VIS_METHOD = "DVI" # DeepVisualInsight
+
+########################################################################################################################
+#                                                     LOAD PARAMETERS                                                  #
+########################################################################################################################
+
+
+parser = argparse.ArgumentParser(description='Process hyperparameters...')
+
+# get workspace dir
+current_path = os.getcwd()
+
+new_path = os.path.join(current_path, 'training_dynamic')
+
+parser.add_argument('--content_path', type=str,default=new_path)
+# parser.add_argument('--start', type=int,default=1)
+# parser.add_argument('--end', type=int,default=3)
+parser.add_argument('--epoch' ,default=3)
+
+# parser.add_argument('--epoch_end', type=int)
+parser.add_argument('--epoch_period', type=int,default=1)
+parser.add_argument('--preprocess', type=int,default=0)
+parser.add_argument('--base',type=bool,default=False)
+args = parser.parse_args()
+
+CONTENT_PATH = args.content_path
+sys.path.append(CONTENT_PATH)
+with open(os.path.join(CONTENT_PATH, "config.json"), "r") as f:
+    config = json.load(f)
+config = config[VIS_METHOD]
+
+# record output information
+# now = time.strftime("%Y-%m-%d-%H_%M_%S", time.localtime(time.time())) 
+# sys.stdout = open(os.path.join(CONTENT_PATH, now+".txt"), "w")
+
+SETTING = config["SETTING"]
+CLASSES = config["CLASSES"]
+DATASET = config["DATASET"]
+PREPROCESS = config["VISUALIZATION"]["PREPROCESS"]
+GPU_ID = config["GPU"]
+GPU_ID = 0
+EPOCH_START = config["EPOCH_START"]
+EPOCH_END = config["EPOCH_END"]
+EPOCH_PERIOD = config["EPOCH_PERIOD"]
+
+EPOCH_START = args.epoch
+EPOCH_END = args.epoch
+EPOCH_PERIOD = args.epoch_period
+
+# Training parameter (subject model)
+TRAINING_PARAMETER = config["TRAINING"]
+NET = TRAINING_PARAMETER["NET"]
+LEN = TRAINING_PARAMETER["train_num"]
+
+# Training parameter (visualization model)
+VISUALIZATION_PARAMETER = config["VISUALIZATION"]
+LAMBDA1 = VISUALIZATION_PARAMETER["LAMBDA1"]
+LAMBDA2 = VISUALIZATION_PARAMETER["LAMBDA2"]
+B_N_EPOCHS = VISUALIZATION_PARAMETER["BOUNDARY"]["B_N_EPOCHS"]
+L_BOUND = VISUALIZATION_PARAMETER["BOUNDARY"]["L_BOUND"]
+ENCODER_DIMS = VISUALIZATION_PARAMETER["ENCODER_DIMS"]
+DECODER_DIMS = VISUALIZATION_PARAMETER["DECODER_DIMS"]
+
+
+
+
+S_N_EPOCHS = VISUALIZATION_PARAMETER["S_N_EPOCHS"]
+N_NEIGHBORS = VISUALIZATION_PARAMETER["N_NEIGHBORS"]
+PATIENT = VISUALIZATION_PARAMETER["PATIENT"]
+MAX_EPOCH = VISUALIZATION_PARAMETER["MAX_EPOCH"]
+
+VIS_MODEL_NAME = 'proxy' ### saved_as 
+
+EVALUATION_NAME = VISUALIZATION_PARAMETER["EVALUATION_NAME"]
+
+# Define hyperparameters
+DEVICE = torch.device("cuda:{}".format(GPU_ID) if torch.cuda.is_available() else "cpu")
+
+import Model.model as subject_model
+net = eval("subject_model.{}()".format(NET))
+
+########################################################################################################################
+#                                                    TRAINING SETTING                                                  #
+########################################################################################################################
+# Define data_provider
+data_provider = NormalDataProvider(CONTENT_PATH, net, EPOCH_START, EPOCH_END, EPOCH_PERIOD, device=DEVICE, epoch_name='Epoch',classes=CLASSES,verbose=1)
+PREPROCESS = args.preprocess
+if PREPROCESS:
+    data_provider._meta_data()
+    if B_N_EPOCHS >0:
+        data_provider._estimate_boundary(LEN // 10, l_bound=L_BOUND)
+
+# Define visualization models
+model = VisModel(ENCODER_DIMS, DECODER_DIMS)
+
+
+# Define Losses
+negative_sample_rate = 5
+min_dist = .1
+_a, _b = find_ab_params(1.0, min_dist)
+umap_loss_fn = UmapLoss(negative_sample_rate, DEVICE, _a, _b, repulsion_strength=1.0)
+recon_loss_fn = ReconstructionLoss(beta=1.0)
+single_loss_fn = SingleVisLoss(umap_loss_fn, recon_loss_fn, lambd=LAMBDA1)
+# Define Projector
+projector = DVIProjector(vis_model=model, content_path=CONTENT_PATH, vis_model_name=VIS_MODEL_NAME, device=DEVICE)
+
+
+
+    
+
+start_flag = 1
+
+prev_model = VisModel(ENCODER_DIMS, DECODER_DIMS)
+
+for iteration in range(EPOCH_START, EPOCH_END+EPOCH_PERIOD, EPOCH_PERIOD):
+    # Define DVI Loss
+    if start_flag:
+        temporal_loss_fn = DummyTemporalLoss(DEVICE)
+        criterion = DVILoss(umap_loss_fn, recon_loss_fn, temporal_loss_fn, lambd1=LAMBDA1, lambd2=0.0,device=DEVICE)
+        start_flag = 0
+    else:
+        # TODO AL mode, redefine train_representation
+        prev_data = data_provider.train_representation(iteration-EPOCH_PERIOD)
+        prev_data = prev_data.reshape(prev_data.shape[0],prev_data.shape[1])
+        curr_data = data_provider.train_representation(iteration)
+        curr_data = curr_data.reshape(curr_data.shape[0],curr_data.shape[1])
+        t_1= time.time()
+        npr = torch.tensor(find_neighbor_preserving_rate(prev_data, curr_data, N_NEIGHBORS)).to(DEVICE)
+        t_2= time.time()
+     
+        temporal_loss_fn = TemporalLoss(w_prev, DEVICE)
+        criterion = DVILoss(umap_loss_fn, recon_loss_fn, temporal_loss_fn, lambd1=LAMBDA1, lambd2=LAMBDA2*npr,device=DEVICE)
+    # Define training parameters
+    optimizer = torch.optim.Adam(model.parameters(), lr=.01, weight_decay=1e-5)
+    lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=4, gamma=.1)
+    # Define Edge dataset
+    
+    ###### generate the skeleton
+
+    skeleton_generator = CenterSkeletonGenerator(data_provider,EPOCH_START,1)
+    # Start timing
+    start_time = time.time()
+    ## gennerate skeleton
+    high_bom,_ = skeleton_generator.center_skeleton_genertaion()
+
+
+    end_time = time.time()
+    elapsed_time = end_time - start_time
+    print("proxy generation finished ")
+    
+
+    t0 = time.time()
+    ##### construct the spitial complex
+    spatial_cons = ProxyBasedSpatialEdgeConstructor(data_provider, iteration, S_N_EPOCHS, B_N_EPOCHS, N_NEIGHBORS, net,high_bom)
+    edge_to, edge_from, probs, feature_vectors, attention = spatial_cons.construct()
+    t1 = time.time()
+
+    print('complex-construct:', t1-t0)
+
+    probs = probs / (probs.max()+1e-3)
+    eliminate_zeros = probs> 1e-3    #1e-3
+    edge_to = edge_to[eliminate_zeros]
+    edge_from = edge_from[eliminate_zeros]
+    probs = probs[eliminate_zeros]
+    
+    dataset = DVIDataHandler(edge_to, edge_from, feature_vectors, attention)
+
+    n_samples = int(np.sum(S_N_EPOCHS * probs) // 1)
+    # chose sampler based on the number of dataset
+    if len(edge_to) > pow(2,24):
+        sampler = CustomWeightedRandomSampler(probs, n_samples, replacement=True)
+    else:
+        sampler = WeightedRandomSampler(probs, n_samples, replacement=True)
+    edge_loader = DataLoader(dataset, batch_size=2000, sampler=sampler, num_workers=8, prefetch_factor=10)
+
+    ########################################################################################################################
+    #                                                       TRAIN                                                          #
+    ########################################################################################################################
+
+    trainer = DVITrainer(model, criterion, optimizer, lr_scheduler, edge_loader=edge_loader, DEVICE=DEVICE)
+
+    t2=time.time()
+    trainer.train(PATIENT, MAX_EPOCH)
+    t3 = time.time()
+    print('training:', t3-t2)
+    # save result
+    save_dir = data_provider.model_path
+    trainer.record_time(save_dir, "time_{}".format(VIS_MODEL_NAME), "complex_construction", str(iteration), t1-t0)
+    trainer.record_time(save_dir, "time_{}".format(VIS_MODEL_NAME), "training", str(iteration), t3-t2)
+    save_dir = os.path.join(data_provider.model_path, "Epoch_{}".format(iteration))
+    trainer.save(save_dir=save_dir, file_name="{}".format(VIS_MODEL_NAME))
+
+    print("Finish epoch {}...".format(iteration))
+
+    prev_model.load_state_dict(model.state_dict())
+    for param in prev_model.parameters():
+        param.requires_grad = False
+    w_prev = dict(prev_model.named_parameters())
+    
+
+########################################################################################################################
+#                                                      VISUALIZATION                                                   #
+########################################################################################################################
+
+from singleVis.visualizer import visualizer
+now = time.strftime("%Y-%m-%d-%H_%M_%S", time.localtime(time.time())) 
+vis = visualizer(data_provider, projector, 200, "tab10")
+save_dir = os.path.join(data_provider.content_path, "Proxy")
+
+if not os.path.exists(save_dir):
+    os.mkdir(save_dir)
+for i in range(EPOCH_START, EPOCH_END+1, EPOCH_PERIOD):
+    vis.savefig(i, path=os.path.join(save_dir, "{}_{}_{}_{}.png".format(DATASET, i, VIS_METHOD,now)))
+    data = data_provider.train_representation(i)
+    data = data.reshape(data.shape[0],data.shape[1])
+
+    ##### save embeddings and background for visualization
+    emb = projector.batch_project(i,data)
+    np.save(os.path.join(CONTENT_PATH, 'Model', 'Epoch_{}'.format(i), 'embedding.npy'), emb)
+    vis.get_background(i,200)
+
+# emb = projector.batch_project(data_provider)
+
+    
+########################################################################################################################
+#                                                       EVALUATION                                                     #
+########################################################################################################################
+# eval_epochs = range(EPOCH_START, EPOCH_END+1, EPOCH_PERIOD)
+# EVAL_EPOCH_DICT = {
+#     "mnist":[1,10,15],
+#     "fmnist":[1,25,50],
+#     "cifar10":[1,100,199]
+# }
+# eval_epochs = EVAL_EPOCH_DICT[DATASET]
+evaluator = Evaluator(data_provider, projector)
+
+
+
+
+Evaluation_NAME = 'proxy_eval'
+for i in range(EPOCH_START, EPOCH_END+1, EPOCH_PERIOD):
+    evaluator.save_epoch_eval(i, 15, temporal_k=5, file_name="{}".format(Evaluation_NAME))

requirements.txt

@@ -0,0 +1,33 @@
+certifi @ file:///croot/certifi_1671487769961/work/certifi
+cycler==0.11.0
+fonttools==4.38.0
+importlib-metadata==6.7.0
+Jinja2==3.1.2
+joblib==1.3.2
+kiwisolver==1.4.5
+kmapper==2.0.1
+llvmlite==0.39.1
+MarkupSafe==2.1.3
+matplotlib==3.5.2
+networkx==2.6.3
+numba==0.56.4
+numpy==1.21.6
+nvidia-cublas-cu11==11.10.3.66
+nvidia-cuda-nvrtc-cu11==11.7.99
+nvidia-cuda-runtime-cu11==11.7.99
+nvidia-cudnn-cu11==8.5.0.96
+packaging==23.2
+Pillow==9.2.0
+pynndescent==0.5.11
+pyparsing==3.1.1
+python-dateutil==2.8.2
+scikit-learn==1.0.2
+scipy==1.7.3
+six==1.16.0
+threadpoolctl==3.1.0
+torch==1.13.1
+tqdm==4.66.1
+typing_extensions==4.7.1
+umap==0.1.1
+umap-learn==0.5.3
+zipp==3.15.0

singleVis/SingleVisualizationModel.py

@@ -0,0 +1,95 @@
+from torch import nn
+
+
+class SingleVisualizationModel(nn.Module):
+    def __init__(self, input_dims, output_dims, units, hidden_layer=3):
+        super(SingleVisualizationModel, self).__init__()
+
+        self.input_dims = input_dims
+        self.output_dims = output_dims
+        self.units = units
+        self.hidden_layer = hidden_layer
+        self._init_autoencoder()
+    
+    # TODO find the best model architecture
+    def _init_autoencoder(self):
+        self.encoder = nn.Sequential(
+            nn.Linear(self.input_dims, self.units),
+            nn.ReLU(True))
+        for h in range(self.hidden_layer):
+            self.encoder.add_module("{}".format(2*h+2), nn.Linear(self.units, self.units))
+            self.encoder.add_module("{}".format(2*h+3), nn.ReLU(True))
+        self.encoder.add_module("{}".format(2*(self.hidden_layer+1)), nn.Linear(self.units, self.output_dims))
+
+        self.decoder = nn.Sequential(
+            nn.Linear(self.output_dims, self.units),
+            nn.ReLU(True))
+        for h in range(self.hidden_layer):
+            self.decoder.add_module("{}".format(2*h+2), nn.Linear(self.units, self.units))
+            self.decoder.add_module("{}".format(2*h+3), nn.ReLU(True))
+        self.decoder.add_module("{}".format(2*(self.hidden_layer+1)), nn.Linear(self.units, self.input_dims))
+
+    def forward(self, edge_to, edge_from):
+        outputs = dict()
+        embedding_to = self.encoder(edge_to)
+        embedding_from = self.encoder(edge_from)
+        recon_to = self.decoder(embedding_to)
+        recon_from = self.decoder(embedding_from)
+        
+        outputs["umap"] = (embedding_to, embedding_from)
+        outputs["recon"] = (recon_to, recon_from)
+
+        return outputs
+
+class VisModel(nn.Module):
+    """define you own visualizatio model by specifying the structure
+
+    """
+    def __init__(self, encoder_dims, decoder_dims):
+        """define you own visualizatio model by specifying the structure
+
+        Parameters
+        ----------
+        encoder_dims : list of int
+            the neuron number of your encoder
+            for example, [100,50,2], denote two fully connect layers, with shape (100,50) and (50,2)
+        decoder_dims : list of int
+            same as encoder_dims
+        """
+        super(VisModel, self).__init__()
+        assert len(encoder_dims) > 1
+        assert len(decoder_dims) > 1
+        self.encoder_dims = encoder_dims
+        self.decoder_dims = decoder_dims
+        self._init_autoencoder()
+    
+    def _init_autoencoder(self):
+        self.encoder = nn.Sequential()
+        for i in range(0, len(self.encoder_dims)-2):
+            self.encoder.add_module("{}".format(len(self.encoder)), nn.Linear(self.encoder_dims[i], self.encoder_dims[i+1]))
+            self.encoder.add_module("{}".format(len(self.encoder)), nn.ReLU(True))
+        self.encoder.add_module("{}".format(len(self.encoder)), nn.Linear(self.encoder_dims[-2], self.encoder_dims[-1]))
+        
+        self.decoder = nn.Sequential()
+        for i in range(0, len(self.decoder_dims)-2):
+            self.decoder.add_module("{}".format(len(self.decoder)), nn.Linear(self.decoder_dims[i], self.decoder_dims[i+1]))
+            self.decoder.add_module("{}".format(len(self.decoder)), nn.ReLU(True))
+        self.decoder.add_module("{}".format(len(self.decoder)), nn.Linear(self.decoder_dims[-2], self.decoder_dims[-1]))
+
+
+    def forward(self, edge_to, edge_from):
+        outputs = dict()
+        embedding_to = self.encoder(edge_to)
+        embedding_from = self.encoder(edge_from)
+        recon_to = self.decoder(embedding_to)
+        recon_from = self.decoder(embedding_from)
+        
+        outputs["umap"] = (embedding_to, embedding_from)
+        outputs["recon"] = (recon_to, recon_from)
+
+        return outputs
+
+
+'''
+The visualization model definition class
+'''