def main(model_name, checkpoint_name, url):
config = Cfg.load_config_from_name(model_name)
dataset_params = {
'name': 'hw',
'data_root': '/home/longhn',
# 'train_root': '/home/fdm/Desktop/chungnph/vietocr/Annotation_2505',
# 'val_root': '/home/fdm/Desktop/chungnph/vietocr/Annotation_2505',
'train_annotation': f'{url}/train.txt',
'valid_annotation': f'{url}/valid.txt'
}
params = {
'print_every': 200,
'valid_every': 10 * 200,
'iters': 30000,
'checkpoint': f'./checkpoint/{checkpoint_name}.pth',
'export': f'./checkpoint/{checkpoint_name}.pth',
'metrics': 15000,
'batch_size': 32
}
dataloader_params = {'num_workers': 1}
# config['pretrain']['cached'] = 'checkpoint/ngaycap_0204.pth'
config['trainer'].update(params)
config['dataset'].update(dataset_params)
config['dataloader'].update(dataloader_params)
config['device'] = 'cuda'
config[
'vocab'] = '''aAàÀảẢãÃáÁạẠăĂằẰẳẲẵẴắẮặẶâÂầẦẩẨẫẪấẤậẬbBcCdDđĐeEèÈẻẺẽẼéÉẹẸêÊềỀểỂễỄếẾệỆfFgGhHiIìÌỉỈĩĨíÍịỊjJkKlLmMnNoOòÒỏỎõÕóÓọỌôÔồỒổỔỗỖốỐộỘơƠờỜởỞỡỠớỚợỢpPqQrRsStTuUùÙủỦũŨúÚụỤưƯừỪửỬữỮứỨựỰvVwWxXyYỳỲỷỶỹỸýÝỵỴzZ0123456789!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ '''
# config['weights'] = 'checkpoint/ngaycap_0204.pth'
print(config)
trainer = Trainer(config, pretrained=True)
trainer.config.save(f'train_config/{checkpoint_name}.yml')
trainer.train()
def main(args):
config.seed = args.seed
random.seed(args.seed)
np.random.seed(args.seed)
if args.gpu_device >= 0:
import torch
torch.cuda.set_device(args.gpu_device)
print("Reading...")
g = read_hin(args.dataset)
el = EdgeLabel(g)
el.split(n_val=0.1, n_test=0.9 - args.train_ratio, seed=args.seed)
if args.mode == 'DistMult':
score = 'inner'
p_reg = 2
proj_name = 'distmult'
elif args.mode == 'TransH1':
score = 'l1'
p_reg = 1
proj_name = 'transh'
elif args.mode == 'TransH2':
score = 'l2'
p_reg = 2
proj_name = 'transh'
t = Trainer(g, el, batch_size=args.batch_size, n_neighbor=args.n_nb, self_loop=True, score=score,
proj_name=proj_name, p_reg=p_reg, l_reg=args.l_reg, degree=args.degree)
t.run(lr=1e-4, patience=args.patience, max_steps=args.max_steps, cuda=True if args.gpu_device >= 0 else False)
def train(self, x_train, kb_words, y_train, x_valid=None, y_valid=None):
trainer = Trainer(self.model,
self.kb_miner,
self.training_config,
checkpoint_path=self.log_dir,
preprocessor=self.p)
trainer.train(x_train, kb_words, y_train, x_valid, y_valid)
def vae_train(config):
config['outdir'].mkdir(parents=True, exist_ok=True)
# get device
if config['use_gpu']:
device = torch.device('cuda')
# moving a tensor to GPU
# useful at BUT cluster to prevent someone from getting the same GPU
fake = torch.Tensor([1]).to(device)
else:
device = torch.device('cpu')
dataset_class = get_dataset(config['dataset_type'])
# compute or load mean and std of dataset
trans = lambda x: logspec(x, **config['spectrum_conf'])
dataset = dataset_class(config['dataset'], transform=trans)
dataloader_meanstd = DataLoader(dataset)
meanstd_norm = get_meanstd_norm(config['meanstd_norm_file'],
dataloader_meanstd)
# load the dataset
trans = lambda x: meanstd_norm(logspec(x, **config['spectrum_conf']))
dataset = dataset_class(config['dataset'], transform=trans)
dataloader_train = DataLoader(dataset,
batch_size=config['batch_size'],
collate_fn=PadCollate(),
shuffle=True)
# create the model
model = SeqVAESpeaker(**config['vae_conf']).to(device)
# store model config
with open(config['outdir'] / 'vae_config', 'w') as f:
json.dump(config['vae_conf'], f, indent=2)
# load loss function
if config['vae_objective'] == 'elbo':
loss = ELBOLoss(model).to(device)
elif config['vae_objective'] == 'elbo_speakerid':
loss = ELBOSpeakerLoss(model, config['speaker_loss_weight']).to(device)
else:
raise KeyError(f'Unknown objective {config["vae_objective"]}')
# run training
trainer = Trainer(model,
loss,
dataloader_train,
config['outdir'],
device=device,
**config['optimizer_conf'])
trainer.run()
def __init__(self, trainX, trainY, penalty=0.00015):
m, n = trainX.shape
o, p = trainY.shape
self.network = NeuralNetwork(n, n + 1, p, penalty)
self.xMax = np.amax(trainX, axis=0)
self.yMax = np.amax(trainY, axis=0)
self.trainX = trainX / self.xMax
self.trainY = trainY / self.yMax
trainer = Trainer(self.network)
trainer.train(self.trainX, self.trainY)
def main(args):
train_data, val_data, test_data, data_parser = read_dataset(args.data,
cuda=args.cuda)
args.max_len = min(args.max_len, data_parser.output_max_len)
input_dict, output_dict = data_parser.input_dict, data_parser.output_dict
net = load_model(args.load_model,
input_dict,
output_dict,
load_last=args.load_last,
eval=True,
cuda=args.cuda)
trainer = Trainer(net, cuda=args.cuda, batch_size=args.batch_size)
if args.print_errors:
print_errors(trainer, data_parser, test_data, args)
train_acc, train_loss, train_time = get_loss_acc(trainer, data_parser,
train_data, args)
print('%sTrain acc %.6f%s' % (bcolors.OKBLUE, train_acc, bcolors.ENDC))
print('%sTrain Loss %.6f%s' % (bcolors.OKBLUE, train_loss, bcolors.ENDC))
val_acc, val_loss, val_time = get_loss_acc(trainer, data_parser, val_data,
args)
print('%sEval acc %.6f%s' % (bcolors.MAGENTA, val_acc, bcolors.ENDC))
print('%sEval Loss %.6f%s' % (bcolors.MAGENTA, val_loss, bcolors.ENDC))
test_acc, test_loss, test_time = get_loss_acc(trainer, data_parser,
test_data, args)
print('%sTest acc %.6f%s' % (bcolors.CYAN, test_acc, bcolors.ENDC))
print('%sTest Loss %.6f%s' % (bcolors.CYAN, test_loss, bcolors.ENDC))
if args.eval_time:
print_times(train_time, val_time, test_time)
def fit(self,
pairs,
save_dir='./checkpoints',
batch_size=64,
teacher_forcing_ratio=1.0,
learning_rate=0.0001,
decoder_learning_ratio=5.0,
n_iteration=4000,
print_every=1,
save_every=500,
clip=50.0):
tr = Trainer(self, teacher_forcing_ratio, self.loadFilename,
learning_rate, decoder_learning_ratio)
tr.trainIters(pairs, save_dir, n_iteration, batch_size, print_every,
save_every, clip, self.corpus_name)
def load_training_model_from_factory(configs, ngpu):
if configs['model']['type'] == 'Encoder':
from model.trainer import Trainer
net, optimizer = load_training_net_from_factory(configs)
loss = load_loss_from_factory(configs)
trainer = Trainer(net, loss, configs['op']['loss'], optimizer, ngpu)
elif configs['model']['type'] == 'GAN':
from model.gan_trainer import Trainer
sr_G, sr_D, optimizerG, optimizerD = load_training_net_from_factory(
configs)
g_loss, d_loss = load_loss_from_factory(configs)
trainer = Trainer(sr_G, sr_D, g_loss, d_loss, optimizerG, optimizerD,
ngpu)
else:
raise Exception("Wrong model type!")
return trainer
def main(args):
# gpu 하나일 때 / colab 기준 환경
device = 'cuda' if torch.cuda.is_available() else 'cpu'
weights_matrix = np.load(args.weights_matrix, allow_pickle=True) # 새로 저장
if args.model == 'bi-lstm':
model = BiLSTM(weights_matrix).to(device)
model_path = ''
elif args.model == 'cnn':
pass
checkpoint = torch.load(args.model_path)
state_dict = checkpoint['net']
model.load_state_dict(state_dict=state_dict)
cls = Trainer(args)
cls.test(model, device)
def main(config):
logger = config.get_logger('train')
# setup data_loader instances
data_loader = config.init_obj('data_loader', module_data, split='train')
valid_data_loader = config.init_obj('data_loader',
module_data,
split='dev')
# build model architecture, then print to console
model = config.init_obj('arch', module_arch)
#logger.info(model)
# get function handles of loss and metrics
criterion = getattr(module_loss, config['loss'])
sentence_metrics = [
getattr(module_metric, met) for met in config['sentence_metrics']
]
term_metrics = [
getattr(module_metric, met) for met in config['term_metrics']
]
# build optimizer, learning rate scheduler.
trainable_params = filter(lambda p: p.requires_grad, model.parameters())
#optimizer = config.init_obj('optimizer', torch.optim, trainable_params)
optimizer = config.init_obj('optimizer', transformers.optimization,
trainable_params)
lr_scheduler = config.init_obj('lr_scheduler', torch.optim.lr_scheduler,
optimizer)
trainer = Trainer(model,
criterion,
sentence_metrics,
term_metrics,
optimizer,
config=config,
data_loader=data_loader,
valid_data_loader=valid_data_loader)
#lr_scheduler=lr_scheduler)
trainer.train()
def train(train_data, val_data, data_parser, args):
input_dict, output_dict = data_parser.input_dict, data_parser.output_dict
net = get_model(input_dict,
output_dict,
args.model,
args.hidden_size,
args.max_len,
args.layers,
args.dropout,
kernel_size=args.kernel_size,
dilate=args.dilate,
ignore_pad=args.ignore_pad,
multilinear=(not args.single_linear),
input_len=data_parser.input_max_len,
stride=args.stride,
attn_heads=args.attn_heads,
cuda=args.cuda)
net.initialize_params(args.init_params)
print(args)
print()
print(net)
print('Number of Elements: %d' %
(sum([x.view(-1).size(0) for x in net.parameters()])))
trainer = Trainer(net,
optim_type=args.optim,
print_every=args.print_every,
cuda=args.cuda,
save_dir=args.save_dir,
save_every=args.save_every,
improve_wait=args.improve_wait,
batch_size=args.batch_size)
if args.train_from:
trainer.load_checkpoint(args.train_from)
trainer.continue_training(data_parser,
train_data,
val_data,
args.epochs,
lr=args.lr,
weight_decay=args.weight_decay)
else:
trainer.train_epochs(data_parser,
train_data,
val_data,
args.epochs,
lr=args.lr,
weight_decay=args.weight_decay)
return trainer
def main(args):
device = 'cuda' if torch.cuda.is_available() else 'cpu'
weights_matrix = np.load(args.weights_matrix, allow_pickle=True) # 새로 저장
if args.model == 'bi-lstm':
model = BiLSTM(weights_matrix).to(device)
model_path = ''
# TO DO
elif args.model == 'cnn':
pass
trainer = Trainer(args)
trainer.train(num_epochs=args.n_epochs,
model=model,
saved_dir=args.save_dir,
device=device,
criterion=torch.nn.BCELoss(),
optimizer=torch.optim.Adam(params=model.parameters(),
lr=1e-5),
val_every=args.val_every)
def load_model(trial_path):
with open(trial_path + "/hyper.csv") as file:
reader = csv.DictReader(file)
for row in reader:
hyper = dict(row)
dataset = hyper['dataset']
model = hyper['model']
batch = int(hyper['batch'])
units_conv = int(hyper['units_conv'])
units_dense = int(hyper['units_dense'])
num_layers = int(hyper['num_layers'])
loss = hyper['loss']
pooling = hyper['pooling']
std = float(hyper['data_std'])
mean = float(hyper['data_mean'])
# Load model
trainer = Trainer(dataset)
trainer.load_data(batch=batch)
trainer.data.std = std
trainer.data.mean = mean
trainer.load_model(model,
units_conv=units_conv,
units_dense=units_dense,
num_layers=num_layers,
loss=loss,
pooling=pooling)
# Load best weight
trainer.model.load_weights(trial_path + "/best_weight.hdf5")
print("Loaded Weights from {}".format(trial_path + "/best_weight.hdf5"))
return trainer, hyper
def main() -> None:
args = TrainArgs.get_args()
train_dataset, dev_dataset, vectors = get_datasets(args)
training_config = get_training_config(args)
with open(f"{args.run_name}_config.json", "w") as config_file:
json.dump(vars(args), config_file, indent=2)
try:
print(f"Attempting to load model to train from {args.run_name}.pth")
model = t.load(f"{args.run_name}.pth").to(training_config.device)
except IOError as e:
print(f"Can't load model: {e}, initializing from scratch")
model = initialize_model(args, train_dataset, vectors)
Trainer.train_model(model,
train_dataset,
dev_dataset,
training_config,
debug=args.debug)
dev_answers = Trainer.answer_dataset(dev_dataset, model, training_config)
gold_answers = dev_dataset.get_gold_answers()
qid_to_answers = {}
for qid, model_answer in dev_answers.items():
qid_to_answers[qid] = {
"model_answer": model_answer,
"gold_answer": gold_answers[qid],
}
with open("dev-pred.json", "w") as f:
json.dump(dev_answers, f)
with open("dev-pred-with-gold.json", "w") as f:
json.dump(qid_to_answers, f)
print("Final evaluation on dev")
eval_results = Trainer.evaluate_on_squad_dataset(dev_dataset, model,
training_config)
print(eval_results)
print(f"Saving model to {args.run_name}.pth")
t.save(model, f"{args.run_name}.pth")
def main(config):
logger = config.get_logger('train')
# setup data_loader instances
data_loader = config.init_obj('data_loader', module_data, split='train')
valid_data_loader = config.init_obj('data_loader',
module_data,
split='dev')
#valid_data_loader = None
# build model architecture, then print to console
model = config.init_obj('arch',
module_arch,
num_classes=data_loader.dataset.num_classes,
vocab_size=len(data_loader.dataset.tokenizer))
#logger.info(model)
# get function handles of loss and metrics
criterion = getattr(module_loss, config['loss'])
metrics = [getattr(module_metric, met) for met in config['metrics']]
# build optimizer, learning rate scheduler. delete every lines containing lr_scheduler for disabling scheduler
trainable_params = filter(lambda p: p.requires_grad, model.parameters())
optimizer = config.init_obj('optimizer', transformers.optimization,
trainable_params)
lr_scheduler = config.init_obj('lr_scheduler', torch.optim.lr_scheduler,
optimizer)
trainer = Trainer(model,
criterion,
metrics,
optimizer,
config=config,
data_loader=data_loader,
valid_data_loader=valid_data_loader)
#lr_scheduler=lr_scheduler)
trainer.train()
def main():
gpus = get_gpus()
print("GPUs: {}".format(gpus))
args = get_user_args()
configs = parser.parse(args.config)
params = setup(configs)
data_loader = DataLoader()
train_datagen = data_loader.get_datagen('train', params)
val_datagen = data_loader.get_datagen('val', params)
model = Model(params)
model.create_model()
model.inspect()
trainer = Trainer(
model.model,
train_datagen,
val_datagen,
params,
)
pprint(params)
trainer.add_callbacks(params)
trainer.train(params)
trainer.model.save(
**params["trained_model"]
)
test_datagen = data_loader.get_datagen('test', params)
step_size = test_datagen.n // test_datagen.batch_size
preds = trainer.model.predict_generator(
test_datagen, verbose=1, steps=step_size
)
predicted_class_indices = np.argmax(preds, axis=1)
labels = dict((v, k) for k, v in (train_datagen.class_indices).items())
predictions = [labels[k] for k in predicted_class_indices]
filenames = test_datagen.filenames
results = pd.DataFrame(
{
"file": filenames,
"prediction": predictions,
"prediction_class": predicted_class_indices,
"cat_proba": [p[0] for p in preds],
"no_cat_proba": [p[1] for p in preds],
"label": test_datagen.classes,
}
)
results_fp = params["results_fp"]
results.to_csv(f"{results_fp}", index=False)
print(results)
def load_best_model(model_dir, model_type="predictor"):
model_file = model_dir + "/best_model.pt"
print("Loading model from {}".format(model_file))
model_opt = torch_utils.load_config(model_file)
if model_type == "predictor":
predictor = Predictor(model_opt)
model = Trainer(model_opt, predictor, model_type=model_type)
else:
selector = Selector(model_opt)
model = Trainer(model_opt, selector, model_type=model_type)
model.load(model_file)
helper.print_config(model_opt)
return model
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--config', required=True, help='see example at ')
parser.add_argument('--checkpoint', required=False, help='your checkpoint')
args = parser.parse_args()
config = Cfg.load_config_from_file(args.config)
trainer = Trainer(config)
if args.checkpoint:
trainer.load_checkpoint(args.checkpoint)
trainer.train()
def get_training_config(args: TrainArgs) -> Trainer.TrainingConfig:
"""
Parse the command line args builds a TrainingConfig object
:param args: TrainArgs object containing invocation parameters
:returns: A well formatted TrainingConfig object that can be used
for training the model
"""
return Trainer.TrainingConfig(
learning_rate=args.lr,
weight_decay=args.weight_decay,
max_grad_norm=args.max_grad_norm,
ema_weight=args.ema_weight,
num_epochs=args.num_epochs,
batch_size=args.batch_size,
max_question_size=args.max_question_size,
max_context_size=args.max_context_size,
device=get_device(args.disable_cuda),
loader_num_workers=args.loader_num_workers,
model_checkpoint_path=args.run_name,
)
def main():
args = parse_args()
# load model
model_file = args.model_file
print("Loading model from {}...".format(model_file))
trainer = Trainer(model_file=model_file)
opt, vocab = trainer.opt, trainer.vocab
trainer.model.eval()
print("Loaded.\n")
# run
while True:
background, findings = get_input(opt)
sum_words = run(background, findings, trainer, vocab, opt)
print(blue("Predicted Impression:\n") + " ".join(sum_words))
print("")
inp = input("Quit (q to quit, otherwise continue)? ")
if inp == 'q':
break
return
def get_trainer(config, model):
optimizer_params = {
'lr': config['lr'],
'lr_decay': config['lr_decay'],
'weight_decay': config['weight_decay'],
'amsgrad': config['amsgrad']
}
loss_params = {
'smoothing': config['smoothing'],
'lm_weight': config['lm_weight'],
'cls_weight': config['cls_weight']
}
amp_params = {
'opt_level': config['opt_level'],
'loss_scale': config['loss_scale']
}
checkpoint_dir = config['checkpoint_dir']
device = config['device']
n_jobs = config['n_jobs']
trainer = Trainer(model, optimizer_params, loss_params, amp_params,
checkpoint_dir, device, n_jobs)
return trainer
def test_mh_model(self):
path_captions = ProjectPaths.text_representation_path
path_embedding_captions = ProjectPaths.embedding_captions_path
path_embedding_images = ProjectPaths.embedding_images_path
text_representation = TextRepresentation(path_captions)
features = ImageRepresentation.load_features(path_embedding_images)
model_builder = ModelBuilder(text_representation, path_embedding_captions)
trainer = Trainer(text_representation, features, model_builder, loss='mh', mini_batch_size=50)
trainer.train(epochs=40)
trainer.save(
image_name=ProjectPaths.image_model_mh_path,
caption_name=ProjectPaths.caption_model_mh_path,
caption_representations_name=ProjectPaths.caption_representations_name,
image_representations_name=ProjectPaths.image_representations_name
)
import sys
sys.path.append('../../')
from model.trainer import Trainer
if __name__ == "__main__":
trainer = Trainer(None)
target_parameters = {
"units_conv": 128,
"units_dense": 128,
"pooling": "max",
"num_layers": 2,
"name": "target"
}
molecule_parameters = {
"units_conv": 128,
"units_dense": 128,
"pooling": "max",
"num_layers": 2,
"name": "molecule"
}
hyperparameters = {
"epoch": 20,
"batch": 16,
"fold": 10,
"loss": "binary_crossentropy",
"monitor": "val_roc",
"label": "",
"target_parameters": target_parameters,
"molecule_parameters": molecule_parameters
model_dir = os.path.join(args.finetune_model, "nnet")
# Set the random seed. The random operations may appear in data input, batch forming, etc.
tf.set_random_seed(params.seed)
random.seed(params.seed)
np.random.seed(params.seed)
dim = FeatureReader(args.train_dir).get_dim()
if "selected_dim" in params.dict:
dim = params.selected_dim
with open(os.path.join(model_dir, "feature_dim"), "w") as f:
f.write("%d\n" % dim)
num_total_train_speakers = KaldiDataRandomQueue(args.train_dir, args.train_spklist).num_total_speakers
tf.logging.info("There are %d speakers in the training set and the dim is %d" % (num_total_train_speakers, dim))
min_valid_loss = ValidLoss()
# The trainer is used to control the training process
trainer = Trainer(params, args.finetune_model, dim, num_total_train_speakers)
trainer.build("train")
trainer.build("valid")
# Load the pre-trained model and transfer to current model
trainer.get_finetune_model(params.noload_var_list)
trainer.train_tune_lr(args.train_dir, args.train_spklist, args.tune_period)
trainer.close()
tf.logging.info("Finish tuning.")
nnet_dir = os.path.join(args.model_dir, "nnet")
config_json = os.path.join(args.model_dir, "nnet/config.json")
if not os.path.isfile(config_json):
sys.exit("Cannot find params.json in %s" % config_json)
params = Params(config_json)
# Change the output node if necessary
if len(args.node) != 0:
params.embedding_node = args.node
tf.logging.info("Extract embedding from %s" % params.embedding_node)
with open(os.path.join(nnet_dir, "feature_dim"), "r") as f:
dim = int(f.readline().strip())
trainer = Trainer(params, args.model_dir, dim, single_cpu=True)
trainer.build("predict")
if args.rspecifier.rsplit(".", 1)[1] == "scp":
# The rspecifier cannot be scp
sys.exit("The rspecifier must be ark or input pipe")
fp_out = open_or_fd(args.wspecifier, "wb")
for index, (key, feature) in enumerate(read_mat_ark(args.rspecifier)):
if feature.shape[0] < args.min_chunk_size:
tf.logging.info("[INFO] Key %s length too short, %d < %d, skip." %
(key, feature.shape[0], args.min_chunk_size))
continue
if feature.shape[0] > args.chunk_size:
feature_array = []
feature_length = []
if __name__ == '__main__':
tf.logging.set_verbosity(tf.logging.INFO)
args = parser.parse_args()
params = save_codes_and_config(True, args.model, None)
# The model directory always has a folder named nnet
model_dir = os.path.join(args.model, "nnet")
# Set the random seed. The random operations may appear in data input, batch forming, etc.
tf.set_random_seed(params.seed)
random.seed(params.seed)
np.random.seed(params.seed)
dim = FeatureReader(args.data_dir).get_dim()
if "selected_dim" in params.dict:
dim = params.selected_dim
with open(args.data_spklist, 'r') as f:
num_total_train_speakers = len(f.readlines())
trainer = Trainer(params, args.model, dim, num_total_train_speakers)
trainer.build("valid")
valid_loss, valid_embeddings, valid_labels = trainer.insight(
args.data_dir,
args.data_spklist,
batch_type=params.batch_type,
output_embeddings=True)
eer = compute_cos_pairwise_eer(valid_embeddings, valid_labels)
tf.logging.info("EER: %f" % eer)
trainer.close()
dim = FeatureReader(args.train_dir).get_dim()
with open(os.path.join(model_dir, "feature_dim"), "w") as f:
f.write("%d\n" % dim)
num_total_train_speakers = KaldiDataRandomQueue(
args.train_dir, args.train_spklist).num_total_speakers
tf.logging.info(
"There are %d speakers in the training set and the dim is %d" %
(num_total_train_speakers, dim))
# Load the history valid loss
min_valid_loss = ValidLoss()
if os.path.isfile(os.path.join(model_dir, "valid_loss")):
min_valid_loss = load_valid_loss(os.path.join(model_dir, "valid_loss"))
# The trainer is used to control the training process
trainer = Trainer(params, args.model)
trainer.build("train",
dim=dim,
loss_type=params.loss_func,
num_speakers=num_total_train_speakers)
trainer.build("valid",
dim=dim,
loss_type=params.loss_func,
num_speakers=num_total_train_speakers)
if "early_stop_epochs" not in params.dict:
params.dict["early_stop_epochs"] = 10
if "min_learning_rate" not in params.dict:
params.dict["min_learning_rate"] = 1e-5
for epoch in range(start_epoch, params.num_epochs):
parser.add_argument('--cuda', type=bool, default=torch.cuda.is_available())
parser.add_argument('--cpu', action='store_true')
args = parser.parse_args()
torch.manual_seed(args.seed)
random.seed(1234)
if args.cpu:
args.cuda = False
elif args.cuda:
torch.cuda.manual_seed(args.seed)
# load opt
model_file = args.model_dir + '/' + args.model
print("Loading model from {}".format(model_file))
opt = torch_utils.load_config(model_file)
trainer = Trainer(opt)
trainer.load(model_file)
# load vocab
vocab_file = args.model_dir + '/vocab.pkl'
vocab = Vocab(vocab_file, load=True)
assert opt[
'vocab_size'] == vocab.size, "Vocab size must match that in the saved model."
char_vocab_file = args.model_dir + '/vocab_char.pkl'
char_vocab = Vocab(char_vocab_file, load=True)
assert opt[
'char_vocab_size'] == char_vocab.size, "Char vocab size must match that in the saved model."
# load data
data_file = opt['data_dir'] + '/{}.jsonl'.format(args.dataset)
from model.trainer import Trainer
if __name__ == "__main__":
trainer = Trainer("hiv")
hyperparameters = {
"epoch": 150,
"batch": 16,
"fold": 10,
"units_conv": 128,
"units_dense": 128,
"pooling": "max",
"num_layers": 2,
"loss": "binary_crossentropy",
"monitor": "val_roc",
"label": ""
}
features = {
"use_atom_symbol": True,
"use_degree": True,
"use_hybridization": True,
"use_implicit_valence": True,
"use_partial_charge": True,
"use_ring_size": True,
"use_hydrogen_bonding": True,
"use_acid_base": True,
"use_aromaticity": True,
"use_chirality": True,
"use_num_hydrogen": True
}
# test_file = 'data/annotated_ner_data/StackOverflow/test.txt' # dataset = reader.read_txt(train_file, -1) # devs = reader.read_txt(dev_file, -1) # tests = reader.read_txt(test_file, -1) dataset = reader.read_txt(conf.train_all_file, -1) # devs = reader.read_txt(conf.dev_file, -1) tests = reader.read_txt(conf.test_file, -1) print(len(dataset)) # setting for data conf.use_iobes(dataset) # conf.use_iobes(devs) conf.use_iobes(tests) conf.build_label_idx(dataset) conf.build_word_idx(dataset, None, tests) conf.build_emb_table() conf.map_insts_ids(dataset) # conf.map_insts_ids(devs) conf.map_insts_ids(tests) random.shuffle(dataset) model = BertCRF(conf).to(conf.device) trainer = Trainer(model, conf, None, tests, use_crf=True) model = trainer.train_model(conf.num_epochs, dataset) # torch.save(model.state_dict(), 'model/softparams.pt')
