add FLEX2 50 MGMOTSPTW EB

MGMOTSPTW/models/FLEX2_50_EB.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea30951f945d83a026ae48437498fd8a283c6197544b9bc214f8406a663e9812
+size 26393840

MGMOTSPTW/test_flex2_50_eb.py

@@ -0,0 +1,159 @@
+##########################################################################################
+# Machine Environment Config
+DEBUG_MODE = False
+USE_CUDA = not DEBUG_MODE
+CUDA_DEVICE_NUM = 0
+
+##########################################################################################
+# Path Config
+import os
+import sys
+import torch
+import numpy as np
+
+os.chdir(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, "..")  # for problem_def
+sys.path.insert(0, "../..")  # for utils
+
+##########################################################################################
+# import
+import logging
+from utils.utils import create_logger, copy_all_src
+
+
+from eb_MGMOTSPTW.MGMOTSPTester import TSPTester
+from MGMOTSPProblemDef import get_random_problems
+
+##########################################################################################
+import time
+import hvwfg
+
+##########################################################################################
+# parameters
+env_params = {
+    'distribution': "FLEX", # FIX or FLEX
+    'problem_size': 50,
+    'pomo_size': 50,
+    'emax': 2
+}
+
+training_method = "Chb" # Linear or Chb
+
+encoder_params = {
+    'embedding_dim': 128,
+    'encoder_layer_num': 6,
+    'qkv_dim': 16,
+    'head_num': 8, 
+    'ff_hidden_dim': 512,
+    "dropout": 0.1, 
+}
+
+decoder_params = {
+    'embedding_dim': 128,
+    'qkv_dim': 16, 
+    'head_num': 8,
+    'logit_clipping': 10,
+    'eval_type': 'argmax',
+}
+decoder_params["training_method"] = training_method
+
+tester_params = {
+    'use_cuda': USE_CUDA,
+    'cuda_device_num': CUDA_DEVICE_NUM,
+    'model_load_path': './result/FLEX2_50.pt',  # path of pre-trained model
+    'data_load_path': './data/FLEX2_50',  # path of test data. If None, random problems will be generated.
+    'reference': [55, 30],
+    'test_episodes': 200, 
+    'test_batch_size': 100,
+    'augmentation_enable': False,
+    'aug_factor': 8,
+    'aug_batch_size': 25
+}
+if tester_params['augmentation_enable']:
+    tester_params['test_batch_size'] = tester_params['aug_batch_size']
+
+logger_params = {
+    'log_file': {
+        'desc': 'test__tsp_n20',
+        'filename': 'run_log'
+    }
+}
+
+### Config end
+
+##########################################################################################
+def _set_debug_mode():
+    global tester_params
+    tester_params['test_episodes'] = 100
+
+def _print_config():
+    logger = logging.getLogger('root')
+    logger.info('DEBUG_MODE: {}'.format(DEBUG_MODE))
+    logger.info('USE_CUDA: {}, CUDA_DEVICE_NUM: {}'.format(USE_CUDA, CUDA_DEVICE_NUM))
+    [logger.info(key + ": {}".format(env_params[key])) for key in env_params.keys()]
+    logger.info('Training Method: {}'.format(training_method))
+    [logger.info(key + ": {}".format(encoder_params[key])) for key in encoder_params.keys()]
+    [logger.info(key + ": {}".format(decoder_params[key])) for key in decoder_params.keys()]
+    [logger.info(key + ": {}".format(tester_params[key])) for key in tester_params.keys()]
+
+def load_problems(path):
+    edge_dists = torch.load(os.path.join(path, "dists"), weights_only=True)
+    edge_to_node = torch.load(os.path.join(path, "edge_to_node"), weights_only=True)
+    service_time = torch.load(os.path.join(path, "service_time"), weights_only=True)
+    tw_start = torch.load(os.path.join(path, "tw_start"), weights_only=True)
+    tw_end = torch.load(os.path.join(path, "tw_end"), weights_only=True)
+    
+    return edge_dists, edge_to_node, service_time, tw_start, tw_end
+
+##########################################################################################
+def main(n_sols = 101):
+    
+    if DEBUG_MODE:
+        _set_debug_mode()
+
+    # We treat depot as any other node
+    env_params['problem_size'] += 1
+    
+    create_logger(**logger_params)
+    _print_config()
+
+    tester = TSPTester(
+                    training_method=training_method,
+                    env_params=env_params,
+                    encoder_params=encoder_params,
+                    decoder_params=decoder_params,
+                    tester_params=tester_params)
+    
+    if tester_params['data_load_path'] is not None:
+        shared_problem, edge_to_node, service_time, tw_start, tw_end = load_problems(tester_params['data_load_path'])
+        edge_attr = shared_problem.to(tester.device)
+        edge_to_node = edge_to_node.to(tester.device)
+        service_time = service_time.to(tester.device)
+        tw_start = tw_start.to(tester.device)
+        tw_end = tw_end.to(tester.device)
+    else:
+        edge_attr, edge_to_node, service_time, tw_start, tw_end = get_random_problems(env_params['distribution'], tester_params['test_episodes'], env_params['problem_size'], env_params['emax'])
+
+    prefs = torch.zeros((n_sols, 2))
+    for i in range(n_sols):
+        prefs[i, 0] = 1 - 0.01 * i
+        prefs[i, 1] = 0.01 * i
+
+    timer_start = time.time()
+
+    sols = tester.run(edge_attr, edge_to_node, service_time, tw_start, tw_end, prefs, print_results=False)
+    
+    timer_end = time.time()
+    
+    total_time = timer_end - timer_start
+    
+    ref = np.asarray(tester_params['reference'])
+    hv = hvwfg.wfg(sols.astype(float), ref.astype(float))
+    hv_ratio =  hv / (ref[0] * ref[1])
+    
+    print('Run Time(s): {:.4f}'.format(total_time))
+    print('HV Ratio: {:.4f}'.format(hv_ratio))
+
+##########################################################################################
+if __name__ == "__main__":
+    main()

MGMOTSPTW/train_flex2_50_eb.py

@@ -0,0 +1,153 @@
+##########################################################################################
+# Machine Environment Config
+DEBUG_MODE = False
+USE_CUDA = not DEBUG_MODE
+CUDA_DEVICE_NUM = 0
+
+##########################################################################################
+# Path Config
+import os
+import sys
+
+os.chdir(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, "..")  # for problem_def
+sys.path.insert(0, "../..")  # for utils
+
+##########################################################################################
+# import
+import logging
+from utils.utils import create_logger, copy_all_src
+
+from MGMOTSPTrainer import TSPTrainer
+
+##########################################################################################
+# parameters
+env_params = {
+    'distribution': "FLEX", # FIX or FLEX
+    'problem_size': 50,
+    'pomo_size': 50,
+    'emax': 2
+}
+
+training_method = "Chb" # Linear or Chb
+curriculum_learning = True
+
+encoder_params = {
+    'embedding_dim': 128,
+    'encoder_layer_num': 6,
+    'qkv_dim': 16,
+    'head_num': 8, 
+    'ff_hidden_dim': 512,
+    "dropout": 0.1, 
+}
+
+decoder_params = {
+    'embedding_dim': 128,
+    'qkv_dim': 16, 
+    'head_num': 8,
+    'logit_clipping': 10,
+    'eval_type': 'argmax',
+}
+decoder_params["training_method"] = training_method
+
+optimizer_params = {
+    'optimizer': {
+        'lr': 1e-4, 
+        'weight_decay': 1e-6
+    },
+    'scheduler': {
+        'milestones': [180,],
+        'gamma': 0.1
+    }
+}
+
+trainer_params = {
+    'use_cuda': USE_CUDA,
+    'cuda_device_num': CUDA_DEVICE_NUM,
+    'epochs': 200,
+    'train_episodes': 100*1000,
+    'train_batch_size': 64,
+    'logging': {
+        'model_save_interval': 5,
+    },
+    'model_load': {
+        'enable': False,  # enable loading pre-trained model
+        'path': './Final_result/edge_50',  # directory path of pre-trained model and log files saved.
+        'epoch': 20,  # epoch version of pre-trained model to laod.
+    }
+}
+
+logger_params = {
+    'log_file': {
+        'desc': 'train__tsp',
+        'filename': 'run_log'
+    }
+}
+
+def curriculum_function(epoch):
+
+    if epoch <= 100:
+        problem_size = 20
+        fwd_batch_size = 64
+    else:
+        problem_size = 50
+        fwd_batch_size = 32
+
+    problem_size = problem_size + 1
+    pomo_size = problem_size - 1
+    batch_size = 64
+    emax = 2
+
+    return problem_size, pomo_size, batch_size, fwd_batch_size, emax
+
+### Config end
+
+##########################################################################################
+# main
+def main():
+    if DEBUG_MODE:
+        _set_debug_mode()
+
+    create_logger(**logger_params)
+
+    _print_config()
+
+    # We treat depot as any other node
+    env_params['problem_size'] += 1
+
+    trainer = TSPTrainer(
+                    training_method=training_method,
+                    env_params=env_params,
+                    curriculum_learning=curriculum_learning,
+                    curriculum_function=curriculum_function,
+                    encoder_params=encoder_params,
+                    decoder_params=decoder_params,
+                    optimizer_params=optimizer_params,
+                    trainer_params=trainer_params)
+
+    copy_all_src(trainer.result_folder)
+
+    trainer.run()
+
+def _set_debug_mode():
+    global trainer_params
+    trainer_params['epochs'] = 1
+    trainer_params['train_episodes'] = 10
+    trainer_params['train_batch_size'] = 10
+
+def _print_config():
+    logger = logging.getLogger('root')
+    logger.info('DEBUG_MODE: {}'.format(DEBUG_MODE))
+    logger.info('USE_CUDA: {}, CUDA_DEVICE_NUM: {}'.format(USE_CUDA, CUDA_DEVICE_NUM))
+    [logger.info(key + ": {}".format(env_params[key])) for key in env_params.keys()]
+    [logger.info("Curriculum Learning: {}".format(curriculum_learning))]
+    [logger.info("Training Method: {}".format(training_method))]
+    [logger.info(key + ": {}".format(encoder_params[key])) for key in encoder_params.keys()]
+    [logger.info(key + ": {}".format(decoder_params[key])) for key in decoder_params.keys()]
+    [logger.info(key + ": {}".format(optimizer_params[key])) for key in optimizer_params.keys()]
+    [logger.info(key + ": {}".format(trainer_params[key])) for key in trainer_params.keys()]
+
+##########################################################################################
+
+if __name__ == "__main__":
+    main()