def __init__(self, config, model):
super(Trainer, self).__init__(config, model)
self.logger = getLogger()
self.tensorboard = get_tensorboard(self.logger)
self.learner = config['learner']
self.learning_rate = config['learning_rate']
self.epochs = config['epochs']
self.eval_step = min(config['eval_step'], self.epochs)
self.stopping_step = config['stopping_step']
self.clip_grad_norm = config['clip_grad_norm']
self.valid_metric = config['valid_metric'].lower()
self.valid_metric_bigger = config['valid_metric_bigger']
self.test_batch_size = config['eval_batch_size']
self.gpu_available = torch.cuda.is_available() and config['use_gpu']
self.device = config['device']
self.checkpoint_dir = config['checkpoint_dir']
ensure_dir(self.checkpoint_dir)
saved_model_file = '{}-{}.pth'.format(self.config['model'],
get_local_time())
self.saved_model_file = os.path.join(self.checkpoint_dir,
saved_model_file)
self.weight_decay = config['weight_decay']
self.start_epoch = 0
self.cur_step = 0
self.best_valid_score = -np.inf if self.valid_metric_bigger else np.inf
self.best_valid_result = None
self.train_loss_dict = dict()
self.optimizer = self._build_optimizer(self.model.parameters())
self.eval_type = config['eval_type']
self.eval_collector = Collector(config)
self.evaluator = Evaluator(config)
self.item_tensor = None
self.tot_item_num = None
def __init__(self, config, model):
super(Trainer, self).__init__(config, model)
self.logger = getLogger()
self.learner = config['learner']
self.learning_rate = config['learning_rate']
self.epochs = config['epochs']
self.eval_step = min(config['eval_step'], self.epochs)
self.stopping_step = config['stopping_step']
self.valid_metric = config['valid_metric'].lower()
self.valid_metric_bigger = config['valid_metric_bigger']
self.test_batch_size = config['eval_batch_size']
self.device = config['device']
self.checkpoint_dir = config['checkpoint_dir']
ensure_dir(self.checkpoint_dir)
saved_model_file = '{}-{}.pth'.format(self.config['model'],
get_local_time())
self.saved_model_file = os.path.join(self.checkpoint_dir,
saved_model_file)
self.start_epoch = 0
self.cur_step = 0
self.best_valid_score = -1
self.best_valid_result = None
self.train_loss_dict = dict()
self.optimizer = self._build_optimizer()
self.eval_type = config['eval_type']
if self.eval_type == EvaluatorType.INDIVIDUAL:
self.evaluator = LossEvaluator(config)
else:
self.evaluator = TopKEvaluator(config)
self.item_tensor = None
self.tot_item_num = None
self.iid_field = config['ITEM_ID_FIELD']
def __init__(self, config, model):
super(Trainer, self).__init__(config, model)
self.logger = getLogger()
self.learner = config['learner']
self.learning_rate = config['learning_rate']
self.epochs = config['epochs']
self.eval_step = min(config['eval_step'], self.epochs)
self.stopping_step = config['stopping_step']
self.clip_grad_norm = config['clip_grad_norm']
self.valid_metric = config['valid_metric'].lower()
self.valid_metric_bigger = config['valid_metric_bigger']
self.test_batch_size = config['eval_batch_size']
self.device = config['device']
self.checkpoint_dir = config['checkpoint_dir']
ensure_dir(self.checkpoint_dir)
saved_model_file = '{}-{}.pth'.format(self.config['model'],
get_local_time())
self.saved_model_file = os.path.join(self.checkpoint_dir,
saved_model_file)
self.weight_decay = config['weight_decay']
self.draw_pic = config['draw_pic']
self.print_latex_code = config['print_latex_code']
self.start_epoch = 0
self.cur_step = 0
self.best_valid_score = -1
self.best_valid_result = None
self.train_loss_dict = dict()
self.optimizer = self._build_optimizer()
self.eval_type = config['eval_type']
self.evaluator = ProxyEvaluator(config)
self.item_tensor = None
self.tot_item_num = None
def __init__(self, config, model):
super(DecisionTreeTrainer, self).__init__(config, model)
self.logger = getLogger()
self.tensorboard = get_tensorboard(self.logger)
self.label_field = config['LABEL_FIELD']
self.convert_token_to_onehot = self.config['convert_token_to_onehot']
# evaluator
self.eval_type = config['eval_type']
self.epochs = config['epochs']
self.eval_step = min(config['eval_step'], self.epochs)
self.valid_metric = config['valid_metric'].lower()
self.eval_collector = Collector(config)
self.evaluator = Evaluator(config)
# model saved
self.checkpoint_dir = config['checkpoint_dir']
ensure_dir(self.checkpoint_dir)
temp_file = '{}-{}-temp.pth'.format(self.config['model'],
get_local_time())
self.temp_file = os.path.join(self.checkpoint_dir, temp_file)
temp_best_file = '{}-{}-temp-best.pth'.format(self.config['model'],
get_local_time())
self.temp_best_file = os.path.join(self.checkpoint_dir, temp_best_file)
saved_model_file = '{}-{}.pth'.format(self.config['model'],
get_local_time())
self.saved_model_file = os.path.join(self.checkpoint_dir,
saved_model_file)
self.stopping_step = config['stopping_step']
self.valid_metric_bigger = config['valid_metric_bigger']
self.cur_step = 0
self.best_valid_score = -np.inf if self.valid_metric_bigger else np.inf
self.best_valid_result = None
def __init__(self, config, model):
super(xgboostTrainer, self).__init__(config, model)
self.xgb = __import__('xgboost')
self.logger = getLogger()
self.label_field = config['LABEL_FIELD']
self.xgb_model = config['xgb_model']
self.convert_token_to_onehot = self.config['convert_token_to_onehot']
# DMatrix params
self.weight = config['xgb_weight']
self.base_margin = config['xgb_base_margin']
self.missing = config['xgb_missing']
self.silent = config['xgb_silent']
self.feature_names = config['xgb_feature_names']
self.feature_types = config['xgb_feature_types']
self.nthread = config['xgb_nthread']
# train params
self.params = config['xgb_params']
self.num_boost_round = config['xgb_num_boost_round']
self.evals = ()
self.obj = config['xgb_obj']
self.feval = config['xgb_feval']
self.maximize = config['xgb_maximize']
self.early_stopping_rounds = config['xgb_early_stopping_rounds']
self.evals_result = {}
self.verbose_eval = config['xgb_verbose_eval']
self.callbacks = None
# evaluator
self.eval_type = config['eval_type']
self.epochs = config['epochs']
self.eval_step = min(config['eval_step'], self.epochs)
self.valid_metric = config['valid_metric'].lower()
self.evaluator = ProxyEvaluator(config)
# model saved
self.checkpoint_dir = config['checkpoint_dir']
ensure_dir(self.checkpoint_dir)
saved_model_file = '{}-{}.pth'.format(self.config['model'],
get_local_time())
self.saved_model_file = os.path.join(self.checkpoint_dir,
saved_model_file)
def __init__(self, config, model):
super(DecisionTreeTrainer, self).__init__(config, model)
self.logger = getLogger()
self.label_field = config['LABEL_FIELD']
self.convert_token_to_onehot = self.config['convert_token_to_onehot']
# evaluator
self.eval_type = config['eval_type']
self.epochs = config['epochs']
self.eval_step = min(config['eval_step'], self.epochs)
self.valid_metric = config['valid_metric'].lower()
self.evaluator = ProxyEvaluator(config)
# model saved
self.checkpoint_dir = config['checkpoint_dir']
ensure_dir(self.checkpoint_dir)
saved_model_file = '{}-{}.pth'.format(self.config['model'], get_local_time())
self.saved_model_file = os.path.join(self.checkpoint_dir, saved_model_file)
def fit(self,
train_data,
valid_data=None,
verbose=True,
saved=True,
show_progress=False,
callback_fn=None):
r"""Train the model based on the train data and the valid data.
Args:
train_data (DataLoader): the train data
valid_data (DataLoader, optional): the valid data, default: None.
If it's None, the early_stopping is invalid.
verbose (bool, optional): whether to write training and evaluation information to logger, default: True
saved (bool, optional): whether to save the model parameters, default: True
show_progress (bool): Show the progress of training epoch and evaluate epoch. Defaults to ``False``.
callback_fn (callable): Optional callback function executed at end of epoch.
Includes (epoch_idx, valid_score) input arguments.
Returns:
(float, dict): best valid score and best valid result. If valid_data is None, it returns (-1, None)
"""
if saved and self.start_epoch >= self.epochs:
self._save_checkpoint(-1)
for epoch_idx in range(self.start_epoch, self.epochs):
# train
training_start_time = time()
train_loss = self._train_epoch(train_data,
epoch_idx,
show_progress=show_progress)
self.train_loss_dict[epoch_idx] = sum(train_loss) if isinstance(
train_loss, tuple) else train_loss
training_end_time = time()
train_loss_output = \
self._generate_train_loss_output(epoch_idx, training_start_time, training_end_time, train_loss)
#if verbose:
# self.logger.info(train_loss_output)
# eval
if self.eval_step <= 0 or not valid_data:
if saved:
self._save_checkpoint(epoch_idx)
update_output = set_color(
'Saving current',
'blue') + ': %s' % self.saved_model_file
#if verbose:
# self.logger.info(update_output)
continue
if (epoch_idx + 1) % self.eval_step == 0:
valid_start_time = time()
valid_score, valid_result = self._valid_epoch(
valid_data, show_progress=show_progress)
self.best_valid_score, self.cur_step, stop_flag, update_flag = early_stopping(
valid_score,
self.best_valid_score,
self.cur_step,
max_step=self.stopping_step,
bigger=self.valid_metric_bigger)
valid_end_time = time()
valid_score_output = (set_color("epoch %d evaluating", 'green') + " [" + set_color("time", 'blue')
+ ": %.2fs, " + set_color("valid_score", 'blue') + ": %f]") % \
(epoch_idx, valid_end_time - valid_start_time, valid_score)
valid_result_output = set_color(
'valid result', 'blue') + ': \n' + dict2str(valid_result)
if verbose:
self.logger.info(valid_score_output)
names = [k for k, _ in valid_result.items()]
values = [round(v, 3) for _, v in valid_result.items()]
my_table = PrettyTable()
my_table.field_names = names
my_table.add_row(values)
print(my_table)
if update_flag:
if saved:
self._save_checkpoint(epoch_idx)
update_output = set_color(
'Saving current best',
'blue') + ': %s' % self.saved_model_file
#if verbose:
# self.logger.info(update_output)
self.best_valid_result = valid_result
if callback_fn:
callback_fn(epoch_idx, valid_score)
if stop_flag:
stop_output = 'Finished training, best eval result in epoch %d' % \
(epoch_idx - self.cur_step * self.eval_step)
if verbose:
self.logger.info(stop_output)
break
if self.draw_loss_pic:
save_path = '{}-{}-train_loss.pdf'.format(self.config['model'],
get_local_time())
self.plot_train_loss(save_path=os.path.join(save_path))
return self.best_valid_score, self.best_valid_result
