add TMAT 50 MOCVRP DH

MOCVRP/models/TMAT_50_DH.pt

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

MOCVRP/test_tmat_50_dh.py

@@ -0,0 +1,174 @@
+##########################################################################################
+# Machine Environment Config
+DEBUG_MODE = False
+USE_CUDA = not DEBUG_MODE
+CUDA_DEVICE_NUM = 0
+
+##########################################################################################
+# Path Config
+import os
+import sys
+import time
+import torch
+import numpy as np
+import hvwfg
+
+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, get_result_folder
+
+from MOCVRP.MOCVRPTester import CVRPTester
+from MOCVRPProblemDef import get_random_problems
+
+##########################################################################################
+# parameters
+env_params = {
+    'problem_size': 50,
+    'pomo_size': 50,
+    'distribution': "TMAT" # EUC, TMAT, XASY
+}
+
+architecture = "GMS-DH" # GMS-DH or GMS-EB
+# GMS-DH: Change GREAT_params and dh_params for encoder
+# GMS-EB: Change GREAT_params for encoder
+
+training_method = "Chb" # Linear or Chb
+
+GREAT_params = {
+    'embedding_dim': 128,
+    'encoder_layer_num': 6,
+    'qkv_dim': 16,
+    'head_num': 8, 
+    'ff_hidden_dim': 512,
+    "great_asymmetric": True,
+    "dropout": 0.1, 
+}
+
+dh_params = {
+    'L1': 5, # GNN layer number, overrides GREAT_params['encoder_layer_num']
+    'L2': 2 # Transformer layer number
+}
+
+decoder_params = {
+    'embedding_dim': 128,
+    'qkv_dim': 16, 
+    'head_num': 8,
+    'logit_clipping': 10,
+    'eval_type': 'argmax',
+}
+
+tester_params = {
+    'use_cuda': USE_CUDA,
+    'cuda_device_num': CUDA_DEVICE_NUM,
+    'model_load_path': './result/TMAT_50_DH.pt',  # path of pre-trained model
+    'data_load_path': './data/TMAT_50',  # path of test data. If None, random problems will be generated.
+    'reference': [40, 3],
+    'test_episodes': 200, 
+    'test_batch_size': 200,
+    '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__cvrp',
+        'filename': 'run_log'
+    }
+}
+
+### Config end
+
+if architecture == "GMS-DH":
+    encoder = "hybrid"
+    decoder = "MP"
+
+    encoder_params = dh_params
+    encoder_params['edge_attention_params'] = GREAT_params
+elif architecture == "GMS-EB":
+    encoder = "GREAT-E"
+    decoder = "MP-E"
+    encoder_params = GREAT_params
+
+decoder_params["training_method"] = training_method
+
+##########################################################################################
+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('Model: {}'.format(architecture))
+    [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):
+    dists = torch.load(os.path.join(path, "dists"), weights_only=True)
+    demands = torch.load(os.path.join(path, "demands"), weights_only=True)
+    
+    return dists, demands
+
+##########################################################################################
+def main(n_sols = 101):
+
+    if DEBUG_MODE:
+        _set_debug_mode()
+
+    create_logger(**logger_params)
+    _print_config()
+
+    # We treat depot as any other node
+    env_params['problem_size'] += 1
+
+    tester = CVRPTester(encoder=encoder,
+                    decoder=decoder,
+                    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_dists, shared_demands = load_problems(tester_params['data_load_path'])
+        shared_dists = shared_dists.to(tester.device)
+        shared_demands = shared_demands.to(tester.device)
+    else:
+        shared_dists, shared_demands = get_random_problems(env_params['distribution'], tester_params['test_episodes'], env_params['problem_size'])
+
+    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(shared_dists, shared_demands, 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()

MOCVRP/train_tmat_50_dh.py

@@ -0,0 +1,173 @@
+##########################################################################################
+# 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 MOCVRPTrainer import CVRPTrainer
+
+##########################################################################################
+# parameters
+env_params = {
+    'problem_size': 50,
+    'pomo_size': 50,
+    'distribution': "TMAT" # EUC, TMAT, XASY
+}
+
+architecture = "GMS-DH" # GMS-DH or GMS-EB
+# GMS-DH: Change GREAT_params and dh_params for encoder
+# GMS-EB: Change GREAT_params for encoder
+
+training_method = "Chb" # Linear or Chb
+curriculum_learning = True
+
+GREAT_params = {
+    'embedding_dim': 128,
+    'encoder_layer_num': 6,
+    'qkv_dim': 16,
+    'head_num': 8, 
+    'ff_hidden_dim': 512,
+    "great_asymmetric": True, # True for TMAT/XASY, False for EUC
+    "dropout": 0.1, 
+}
+
+dh_params = {
+    'L1': 5, # GNN layer number, overrides GREAT_params['encoder_layer_num']
+    'L2': 2 # Transformer layer number
+}
+
+decoder_params = {
+    'embedding_dim': 128,
+    'qkv_dim': 16, 
+    'head_num': 8,
+    'logit_clipping': 10,
+    'eval_type': 'argmax',
+}
+
+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__cvrp',
+        'filename': 'run_log'
+    }
+}
+
+def curriculum_function(epoch):
+
+    if epoch <= 100:
+        problem_size = 20
+    elif epoch <= 200:
+        problem_size = 50
+        
+    batch_size = 64
+    fwd_batch_size = batch_size
+    problem_size += 1
+    pomo_size = problem_size - 1
+
+    return problem_size, pomo_size, batch_size, fwd_batch_size
+
+### Config end
+
+if architecture == "GMS-DH":
+    encoder = "hybrid"
+    decoder = "MP"
+
+    encoder_params = dh_params
+    encoder_params['edge_attention_params'] = GREAT_params
+elif architecture == "GMS-EB":
+    encoder = "GREAT-E"
+    decoder = "MP-E"
+    encoder_params = GREAT_params
+
+decoder_params["training_method"] = training_method
+##########################################################################################
+# 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 = CVRPTrainer(encoder=encoder,
+                    decoder=decoder,
+                    training_method=training_method,
+                    curriculum_learning=curriculum_learning,
+                    curriculum_function=curriculum_function,
+                    env_params=env_params,
+                    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('Model: {}'.format(architecture))
+    [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()