def self_test_train():
""" Self test the model with toy data, training part.
"""
# Load and prepare fake data
buckets, buckets_collapsed, bucket_sizes, train_tuple_b, word2id, word_embeddings = \
fake_data_with_buckets()
mydata = MyData(train_tuple_b, train_tuple_b, train_tuple_b, word2id, word_embeddings)
assert(mydata.train_buckets == buckets)
assert(mydata.train_bucket_sizes == bucket_sizes)
assert(mydata.valid_buckets == buckets)
assert(mydata.valid_bucket_sizes == bucket_sizes)
buckets_t = zip(*buckets)
# Create model with vocabulary of 10, 2 small buckets
config = SelfTestConfig()
config.vocab_size = 10
config.max_sentence_num = max(buckets_t[0])
config.max_question_length = max(buckets_t[1])
config.max_sentence_length = max(buckets_t[2])
config.data_type = data_type()
config.init_scale = np.sqrt(6.0 / (config.word_embed_size + config.rnn_hidden_size))
eval_config = SelfTestConfig()
eval_config.vocab_size = 10
eval_config.max_question_length = max(buckets_t[1])
eval_config.max_sentence_num = max(buckets_t[0])
eval_config.max_sentence_length = max(buckets_t[2])
eval_config.data_type = data_type()
eval_config.batch_size = 2
eval_config.init_scale = np.sqrt(6.0 / (config.word_embed_size + config.rnn_hidden_size))
with tf.Session() as session:
# Set random seed to fixed number
tf.set_random_seed(FLAGS.tf_random_seed)
random.seed(FLAGS.random_seed)
np.random.seed(FLAGS.random_seed)
initializer = tf.random_uniform_initializer(-config.init_scale,
config.init_scale)
embedding_initializer = tf.constant_initializer(word_embeddings,
dtype=config.data_type)
with tf.variable_scope("model", reuse=None, initializer=initializer):
m = MIL_AnswerTrigger(config=config, buckets=buckets,
embedding_initializer=embedding_initializer)
with tf.variable_scope("model", reuse=True, initializer=initializer):
m_valid = MIL_AnswerTrigger(config=eval_config, buckets=buckets,
is_training=False,
embedding_initializer=embedding_initializer)
train_model(FLAGS, session, m, config, mydata, m_valid)
save_checkpoint(FLAGS, session, m)
def train():
"""Train the model."""
buckets = BUCKETS
train_tuple_b, valid_tuple_b, test_tuple_b, word2id, word_embeddings = \
prep_data()
mydata = MyData(train_tuple_b, valid_tuple_b, test_tuple_b,
word2id, word_embeddings)
assert(mydata.train_buckets == buckets)
assert(mydata.valid_buckets == buckets)
buckets_t = zip(*buckets)
# Create model
config = get_config()
config.vocab_size = len(word2id)
config.max_sentence_num = max(buckets_t[0])
config.max_question_length = max(buckets_t[1])
config.max_sentence_length = max(buckets_t[2])
config.data_type = data_type()
config.init_scale = np.sqrt(6.0 / (config.word_embed_size + config.rnn_hidden_size))
print_config(config)
eval_config = get_config()
eval_config.vocab_size = len(word2id)
eval_config.max_sentence_num = max(buckets_t[0])
eval_config.max_question_length = max(buckets_t[1])
eval_config.max_sentence_length = max(buckets_t[2])
eval_config.data_type = data_type()
eval_config.batch_size = 10
eval_config.init_scale = np.sqrt(6.0 / (config.word_embed_size + config.rnn_hidden_size))
with tf.Session() as session:
# Set random seed to fixed number
tf.set_random_seed(FLAGS.tf_random_seed)
random.seed(FLAGS.random_seed)
np.random.seed(FLAGS.random_seed)
initializer = tf.random_uniform_initializer(-config.init_scale,
config.init_scale)
embedding_initializer = tf.constant_initializer(word_embeddings,
dtype=config.data_type)
with tf.variable_scope("model", reuse=None, initializer=initializer):
m = MIL_AnswerTrigger(config=config, buckets=buckets,
embedding_initializer=embedding_initializer)
with tf.variable_scope("model", reuse=True, initializer=initializer):
m_valid = MIL_AnswerTrigger(config=eval_config, buckets=buckets,
is_training=False,
embedding_initializer=embedding_initializer)
train_model(FLAGS, session, m, config, mydata, m_valid)
def main():
config = get_config()
if config['train'] and not config['resume']:
for key in ['folder_log', 'folder_out']:
if os.path.exists(config[key]):
raise FileExistsError(config[key])
os.makedirs(config[key])
with open(os.path.join(config['folder_out'], 'config.yaml'), 'w') as f:
yaml.safe_dump(config, f)
data_loaders, image_shape = get_data_loaders(config)
config['image_shape'] = image_shape
net = get_model(config)
if config['train']:
train_model(config, data_loaders, net)
test_model(config, data_loaders, net)
return
def main():
gpus = tf.config.experimental.list_physical_devices('GPU')
for gpu in gpus:
tf.config.experimental.set_memory_growth(gpu, True)
config = get_config()
if config['train'] and not config['resume']:
for key in ['folder_log', 'folder_out']:
if os.path.exists(config[key]):
raise FileExistsError(config[key])
os.makedirs(config[key])
with open(os.path.join(config['folder_out'], 'config.yaml'), 'w') as f:
yaml.safe_dump(config, f)
strategy = tf.distribute.MirroredStrategy()
data_loaders = get_data_loaders(strategy, config)
net = get_model(config)
if config['train']:
train_model(strategy, config, data_loaders, net)
test_model(strategy, config, data_loaders, net)
return
def main():
config = get_config()
if config['train'] and not config['resume']:
for key in ['folder_log', 'folder_out']:
if os.path.exists(config[key]):
raise FileExistsError(config[key])
os.makedirs(config[key])
with open(os.path.join(config['folder_out'], 'config.yaml'), 'w') as f:
yaml.safe_dump(config, f)
data_loaders, image_shape = get_data_loaders(config)
config['image_shape'] = image_shape
if 'crop_shape' not in config:
config['crop_shape'] = [
val if idx == 0 else val // 2
for idx, val in enumerate(image_shape)
]
net = get_model(config)
net_gen = None if config['path_pretrain'] is None else get_model(config)
if config['train']:
train_model(config, data_loaders, net, net_gen)
test_model(config, data_loaders, net)
return
def main():
parser = argparse.ArgumentParser(description='Trainning model ... ')
#
'''
modify here accordingly ...
'''
#
parser.add_argument('-fd',
'--FileData',
required=False,
help='Path of the dataset')
#
parser.add_argument('-d',
'--DimModel',
required=False,
help='Dimension of LSTM model ')
parser.add_argument('-s',
'--Seed',
required=False,
help='Seed of random state')
#
parser.add_argument('-fp',
'--FilePretrain',
required=False,
help='File of pretrained model')
parser.add_argument('-me',
'--MaxEpoch',
required=False,
help='Max epoch number of training')
parser.add_argument('-op',
'--Optimizer',
required=False,
help='Optimizer of training')
#
parser.add_argument('-do',
'--DropOut',
required=False,
help='Drop-out rate')
#
parser.add_argument('-m1',
'--Map1',
required=False,
help='First Train Map')
parser.add_argument('-m2',
'--Map2',
required=False,
help='Second Train Map')
#
args = parser.parse_args()
#
if args.FileData == None:
args.FileData = None
#
if args.MaxEpoch == None:
args.MaxEpoch = numpy.int32(2)
else:
args.MaxEpoch = numpy.int32(args.MaxEpoch)
if args.Optimizer == None:
args.Optimizer = 'adam'
else:
args.Optimizer = args.Optimizer
#
if args.DimModel == None:
args.DimModel = numpy.int32(100)
else:
args.DimModel = numpy.int32(args.DimModel)
if args.Seed == None:
args.Seed = numpy.int32(12345)
else:
args.Seed = numpy.int32(args.Seed)
if args.DropOut == None:
args.DropOut = numpy.float32(0.9)
else:
args.DropOut = numpy.float32(args.DropOut)
#
if args.Map1 == None:
args.Map1 = 'grid'
else:
args.Map1 = str(args.Map1)
if args.Map2 == None:
args.Map2 = 'jelly'
else:
args.Map2 = str(args.Map2)
#
id_process = os.getpid()
time_current = datetime.datetime.now().isoformat()
#
tag_model = '_PID=' + str(id_process) + '_TIME=' + time_current
#
path_track = './tracks/track' + tag_model + '/'
file_log = os.path.abspath(path_track + 'log.txt')
path_save = path_track
command_mkdir = 'mkdir -p ' + os.path.abspath(path_track)
os.system(command_mkdir)
#
## show values ##
'''
'--FileData', '--DimModel', '--Seed'
'--FilePretrain', '--MaxEpoch', '--Optimizer'
'--DropOut', '--Map1', '--Map2'
'''
print("PID is : %s" % str(id_process))
print("TIME is : %s" % time_current)
#
print("FileData is : %s" % args.FileData)
print("DimModel is : %s" % str(args.DimModel))
print("Seed is : %s" % str(args.Seed))
print("FilePretrain is : %s" % args.FilePretrain)
print("MaxEpoch is : %s" % str(args.MaxEpoch))
print("Optimizer is : %s" % args.Optimizer)
print("DropOut is : %s" % str(args.DropOut))
print("Map1 is : %s" % str(args.Map1))
print("Map2 is : %s" % str(args.Map2))
#
dict_args = {
'PID': id_process,
'TIME': time_current,
'FileData': args.FileData,
'DimModel': args.DimModel,
'Seed': args.Seed,
'FilePretrain': args.FilePretrain,
'MaxEpoch': args.MaxEpoch,
'Optimizer': args.Optimizer,
'DropOut': args.DropOut,
'Map1': args.Map1,
'Map2': args.Map2
}
#
input_trainer = {
'random_seed': args.Seed,
'path_rawdata': args.FileData,
'path_start_model': args.FilePretrain,
'drop_out_rate': args.DropOut,
'max_epoch': args.MaxEpoch,
'dim_model': args.DimModel,
'optimizer': args.Optimizer,
'save_file_path': path_save,
'log_file': file_log,
'args': dict_args,
'maps_train': [args.Map1, args.Map2]
}
#
run_model.train_model(input_trainer)
help="log metrics to Weights & Biases",
)
args = parser.parse_args()
date_now = datetime.datetime.now().strftime("%Y-%m-%d-%H-%M-%S-%f")
current_dir = os.path.dirname(os.path.realpath(__file__))
outputs_dir = os.path.join(current_dir, os.pardir, os.pardir, os.pardir,
"outputs", "training")
outputs_dir = os.path.normpath(outputs_dir)
args.output_dir = os.path.join(outputs_dir,
f"{args.model}-{args.dataset}-{date_now}/")
train_dataset = load_ocnliDataset()
train_hugdataset = HuggingFaceDataset(train_dataset)
val_dataset = load_ocnliDataset(split="dev")
val_hugdataset = HuggingFaceDataset(val_dataset)
train_text, train_labels, eval_text, eval_labels = dataset_for_training(
train_hugdataset, val_hugdataset)
config = BertConfig.from_pretrained(
args.tokenizer) # "hfl/chinese-macbert-base"
config.output_attentions = False
config.output_token_type_ids = False
# config.max_length = 30
tokenizer = BertTokenizerFast.from_pretrained(args.tokenizer,
config=config,
max_length=35)
train_model(args, train_text, train_labels, eval_text, eval_labels, tokenizer)
map_sequence = ['grid', 'l', 'jelly']
if __name__ == '__main__':
print('Start Map tester ...')
# declare the parser
parser = argparse.ArgumentParser(description='run the hong yuan moel')
# add the argument
parser.add_argument('-log_file', help='log file content', required=True)
parser.add_argument('-save_file_path',
help='save file path',
required=True)
parser.add_argument('-seed', help='random seed', required=True)
parser.add_argument('-test_map', help='map_for_test', required=True)
parser.add_argument('-dim_model', help='depth of the model', default=100)
# parse the argument
args = parser.parse_args()
input_trainer['log_file'] = args.log_file
input_trainer['save_file_path'] = args.save_file_path
input_trainer['seed'] = int(args.seed)
input_trainer['maps_train'] = [
map_sequence[idx] for idx in range(3) if idx != int(args.test_map)
]
input_trainer['dim_model'] = int(args.dim_model)
print(input_trainer)
run_model.train_model(input_trainer)
args = get_arguments()
# dataloaders, args.image_planes, args.image_full_height, args.image_full_width = get_dataloaders(args)
dataloaders, image_shapes = get_data_loaders(args)
args.image_planes, args.image_full_height, args.image_full_width = image_shapes
args.image_crop_height = args.image_full_height // 2
args.image_crop_width = args.image_full_width // 2
if args.train:
if not os.path.exists(args.folder):
os.mkdir(args.folder)
exclude_keys = [
'path_config',
'folder',
'train',
'file_args',
'file_log',
'file_model',
'file_result_base',
]
args_dict = {
key: val
for key, val in args.__dict__.items() if key not in exclude_keys
}
with open(os.path.join(args.folder, args.file_args), 'w') as f:
yaml.safe_dump(args_dict, f)
net = get_model(args).cuda()
train_model(args, net, dataloaders)
else:
net = get_model(args, os.path.join(args.folder,
args.file_model)).cuda()
test_model(args, net, dataloaders)
def main():
parser = argparse.ArgumentParser(description='Trainning model ... ')
#
# The directory from which to find the data. default in data_processors is './data/'
parser.add_argument('-fd',
'--FileData',
required=False,
help='Path of the dataset')
#
parser.add_argument('-d',
'--DimModel',
required=False,
help='Dimension of LSTM model ')
parser.add_argument('-s',
'--Seed',
required=False,
help='Seed of random state')
parser.add_argument('-fp',
'--FilePretrain',
required=False,
help='File of pretrained model')
parser.add_argument('-me',
'--MaxEpoch',
required=False,
help='Max epoch number of training')
parser.add_argument('-do',
'--DropOut',
required=False,
help='Drop-out rate')
#
parser.add_argument('-m1',
'--Map1',
required=False,
help='First Train Map')
parser.add_argument('-m2',
'--Map2',
required=False,
help='Second Train Map')
parser.add_argument(
'-vl',
'--Validation',
required=False,
action='store_true',
help='validate trained model (True/False, default is false)')
parser.add_argument(
'-sb',
'--SizeBeam',
required=False,
choices=range(1, 20),
default=4,
help='Validation mode: Size of Beam (Integer, default is 4)')
parser.add_argument(
'-lnf',
'--LengthNormalizationFactor',
required=False,
default=0.5,
help=
'Validation mode: Length Normalization Factor [0.5-0.7] (0.5 is the default)'
)
args = parser.parse_args()
if args.MaxEpoch is None:
args.MaxEpoch = numpy.int32(20)
else:
args.MaxEpoch = numpy.int32(args.MaxEpoch)
if args.DimModel is None:
args.DimModel = numpy.int32(100)
else:
args.DimModel = numpy.int32(args.DimModel)
if args.Seed is None:
args.Seed = numpy.int32(90001)
else:
args.Seed = numpy.int32(args.Seed)
if args.DropOut is None:
args.DropOut = numpy.float32(0.9)
else:
args.DropOut = numpy.float32(args.DropOut)
#
if args.Map1 is None:
args.Map1 = 'map_2'
else:
args.Map1 = str(args.Map1)
if args.Map2 is None:
args.Map2 = 'map_3'
else:
args.Map2 = str(args.Map2)
assert isinstance(args.LengthNormalizationFactor, float)
assert 0.5 <= args.LengthNormalizationFactor <= 0.7
assert isinstance(args.SizeBeam, int), "Size of Beam is not an int"
id_process = os.getpid()
time_current = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
#
tag_model = '_PID=' + str(id_process) + '_TIME=' + time_current
#
path_track = './tracks/track' + tag_model + '/'
file_log = os.path.join(path_track + 'log.txt')
if not os.path.exists(path_track):
os.makedirs(path_track)
args.path_save = os.path.abspath(path_track)
logger = create_logger(file_log, 'trainer log')
logger.info(args)
run_model.train_model(args)
