self.cur_epoch += 1
idx = self.idxes[self.cnt]#idx % len(self.steps)
self.cnt += 1
tokens = [self.config.encode[i] for i in self.steps[idx][0]]
goal_tokens = torch.Tensor(tokens).long().to(self.args.device)
goal_tree = torch.Tensor(self.steps[idx][1]).to(self.args.device)
#print (self.cnt)
return goal_tokens, goal_tree, self.steps[idx][2]
def __len__(self):
return self.length
if __name__ == "__main__":
#parser = argparse.ArgumentParser(description='loader')
#parser.add_argument('--data-path', type=str, default='../data/')
#parser.add_argument('--split', type=str, default='train')
#parser.add_argument('--negative-samples', type=int, default=4)
#parser.add_argument('--num_workers')
#args = parser.parse_args()
args = params.get_args()
args.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
loader = torch.utils.data.DataLoader(
MetaMath(args), collate_fn=mycollate,
batch_size=10, shuffle=False, num_workers=0)#args.num_workers)
t = time.time()
for i in range(100):
data = next(iter(loader))
print ((time.time()-t)/(i+1))
print (data)
#print (data)
def train_baseline_model():
args = params.get_args()
if args.task == 'pred':
data_loader = data_loader_pred
data_loader_eval = data_loader
elif args.task == 'gen':
data_loader_eval = data_loader_gen
if not args.gen_noproof:
data_loader = data_loader_gen
else:
data_loader = data_loader_gen_noproof
else:
print ('unknown task: %s' % (args.task))
return
_logger = log.get_logger(__name__, args)
_logger.info(print_args(args))
valid_split = 'valid' if args.evaluate =='none' else args.evaluate
train_split = 'valid' if args.goal_debug else 'train'
if args.evaluate == 'none':
trainloader = torch.utils.data.DataLoader(
data_loader.MetaMath(args, split=train_split), collate_fn=data_loader.mycollate,
batch_size=args.batch_size, shuffle=True,
num_workers=0)
validloader = torch.utils.data.DataLoader(
data_loader_eval.MetaMath(args, split=valid_split, evaluate=True),
collate_fn=data_loader_eval.mycollate,
batch_size=args.batch_size, shuffle=False,
num_workers=0)
if args.partial_lm:
lm = build_language_model(args.num_props, new=args.gen_lm, _all=False)
else:
lm = load_language_model(_all=False, new=args.gen_lm, iset=args.iset)
config = get_config(lm)
args.vocab_size = len(config.encode)+1
generator = None
if args.task == 'pred':
model = torch_models.PredModel(args, config).to(args.device)
elif args.task == 'gen':
model = torch_models.GenModel2(args, config).to(args.device)
training_object = trainer.Trainer(args, config, model, generator, _logger, validloader)
if args.pretrained != '':
model.load(args.pretrained)
data = torch.load(args.pretrained)
if not hasattr(args, 'start_zero') or not args.start_zero:
training_object.cur_epoch = data['aux']['epoch']+1
if args.evaluate != 'none':
with torch.no_grad():
training_object.evaluate()
return
while training_object.cur_epoch < args.epoch:
if training_object.cur_epoch in args.schedule:
adjust_lr(training_object.model_opt, args)
training_object.train_from_loader(trainloader)
training_object.evaluate()
aux = {'epoch':training_object.cur_epoch, 'cur_iter':9999}
save_model(aux, args, training_object.model, opt=None)
training_object.cur_epoch += 1
action = agent.choose_action(state) # 根据当前环境state选择action
next_state, reward, done, _ = env.step(action)
ep_reward += reward
state = next_state
if done:
print('Episode:', i_episode, ' Reward:', ep_reward)
break
rewards.append(ep_reward)
if i_episode == 0:
moving_average_rewards.append(ep_reward)
else:
moving_average_rewards.append(0.9 * moving_average_rewards[-1] +
0.1 * ep_reward)
writer.add_scalars('rewards', {
'raw': rewards[-1],
'moving_average': moving_average_rewards[-1]
}, i_episode + 1)
writer.close()
print('Complete evaling！')
if __name__ == "__main__":
cfg = get_args()
if cfg.train:
train(cfg)
eval(cfg)
else:
model_path = os.path.split(
os.path.abspath(__file__))[0] + "/saved_model/"
eval(cfg, saved_model_path=model_path)
def main():
cfg = get_args()
# train(cfg)
test(cfg)
