def perform_subset_tests(train_subsets, test_subsets, tables=False, quantitive=True, plot=False, proj_mode_list=PROJECTION_MODE_LIST, train_test_exclusivity = False, verbosity = 2):
"""
Performs attribute selection experiments for given parameters.
:param train_subsets: attribute subsets to use for training.
:param test_subsets: attribute subsets to use for testing.
:param tables: print tables or not?
:param quantitive: print quantitative evaluation or not?
:param plot: print plots or not? (not yet included)
:param proj_mode_list: a list of projection modes.
:param train_test_exclusivity: zero-shot or normal setting.
:param verbosity:
:return:
"""
if train_test_exclusivity:
for train_set in train_subsets:
for test_set in test_subsets:
if not train_set[0] == 'ALL' and not (train_set[0] == test_set[0]): #nicht auf ALL trainieren, da das alle testsets subsummiert UND train und test nicht gleich, da dann auch testmenge = []
print("-----------------------")
output = "Train: {}, Test: {} \\ {}".format(train_set[0], test_set[0], train_set[0])
print(output)
sys.stdout.flush()
else:
for train_set in train_subsets:
for test_set in test_subsets:
print("-----------------------")
output = "Train: %s, Test: %s" % (train_set[0], test_set[0])
print(output)
evaluate(train_set[1],test_set[1], proj_mode_list, tables=tables, plot=plot, quantitive_eval=quantitive,train_test_exclusivity = train_test_exclusivity, verbosity=verbosity)
sys.stdout.flush()
def main():
flags = parse_flags()
hparams = parse_hparams(flags.hparams)
if flags.mode == 'train':
utils.resample(sample_rate=flags.sample_rate, dir=flags.train_clip_dir, csv_path=flags.train_csv_path)
train.train(model_name=flags.model, hparams=hparams,
class_map_path=flags.class_map_path,
train_csv_path=flags.train_csv_path,
train_clip_dir=flags.train_clip_dir+'/resampled',
train_dir=flags.train_dir, sample_rate=flags.sample_rate)
elif flags.mode == 'eval':
#TODO uncomment
#utils.resample(sample_rate=flags.sample_rate, dir=flags.eval_clip_dir, csv_path=flags.eval_csv_path)
evaluation.evaluate(model_name=flags.model, hparams=hparams,
class_map_path=flags.class_map_path,
eval_csv_path=flags.eval_csv_path,
eval_clip_dir=flags.eval_clip_dir+'/resampled',
checkpoint_path=flags.checkpoint_path)
else:
assert flags.mode == 'inference'
utils.resample(sample_rate=flags.sample_rate, dir=flags.test_clip_dir, csv_path='test')
inference.predict(model_name=flags.model, hparams=hparams,
class_map_path=flags.class_map_path,
test_clip_dir=flags.test_clip_dir,
checkpoint_path=flags.checkpoint_path,
predictions_csv_path=flags.predictions_csv_path)
def evaluteFullFile(filename):
tempname = "tmp_" + filename
temp = open(tempname, "w")
for row in open(filename, "r").readlines():
if int(row.split()[3]) > 49:
continue
temp.write(row)
temp.flush()
evaluate(tempname, "dev2014", "__eval.csv", [])
deleteFile(tempname)
def main(arguments):
if len(arguments)<3:
print("usage: rank.py training_data test_data outputFile")
training_data_file = arguments[0]
test_data_file = arguments[0]
output_file = arguments[2]
#md.trainRanker(training_data_file)
md.testRanker(test_data_file)
md.rank(test_data_file,output_file)
ev.evaluate(output_file)
def get_trained_model(training_data_directory, model_name):
#Get training data
X, y = get_training_data(training_data_directory)
#Split training data
X_train, X_test, y_train, y_test = training.training.split_data(X, y, 0.3)
#Determine n_estimators to use
#evaluate_n_estimators(X_train, X_test, y_train, y_test)
#Train classifier
training.train_random_forest(X_train, y_train, 200, model_name)
evaluation.evaluate(model_name, X_test, y_test)
def add_module_to_env(name, env):
with open('lib/%s.fr' % name) as f:
raw_string = ''.join(f.readlines())
imported_ast = parse.Parser(raw_string).parse_expression()
imported_val = evaluation.evaluate(imported_ast, env)
imported_env = env.copy_with(imported_val.env.dictionary)
return imported_env
def test(args):
test_set = Dataset.from_bin_file(args.test_file)
assert args.load_model
print('load model from [%s]' % args.load_model, file=sys.stderr)
params = torch.load(args.load_model, map_location=lambda storage, loc: storage)
vocab = params['vocab']
transition_system = params['transition_system']
saved_args = params['args']
saved_state = params['state_dict']
saved_args.cuda = args.cuda
# set the correct domain from saved arg
args.lang = saved_args.lang
update_args(saved_args)
parser_cls = get_parser_class(saved_args.lang)
parser = parser_cls(saved_args, vocab, transition_system)
parser.load_state_dict(saved_state)
if args.cuda: parser = parser.cuda()
parser.eval()
eval_results, decode_results = evaluation.evaluate(test_set.examples, parser, args,
verbose=args.verbose, return_decode_result=True)
print(eval_results, file=sys.stderr)
if args.save_decode_to:
pickle.dump(decode_results, open(args.save_decode_to, 'wb'))
def perform_test(train_set,test_set, tables=False, quantitive=True, plot=False, proj_mode_list=PROJECTION_MODE_LIST, train_test_exclusivity = False, verbosity = 2):
"""
Performs attribute experiment for given parameters.
:param train_set: Attribute set for training.
:param test_set: Attribute set for testing.
:param tables: print tables or not?
:param quantitive: print quantitative evaluation or not?
:param plot: print plots or not? (not yet included)
:param proj_mode_list: a list of projection modes.
:param train_test_exclusivity: zero-shot or normal setting.
:param verbosity:
:return:
"""
print("-----------------------")
output = "Train: %s, Test: %s" % (train_set[0], test_set[0])
print(output)
evaluate(train_set[1],test_set[1], proj_mode_list, tables=tables, plot=plot, quantitive_eval=quantitive, train_test_exclusivity = train_test_exclusivity, verbosity=verbosity)
sys.stdout.flush()
def test(name):
classifier = svm.LinearSVC()
knn_classifier = neighbors.KNeighborsClassifier(n_neighbors=5)
# classifier = LogisticRegression()
LTM_t_fea = topic_modeling.load_t_fea(name, "LTM", 20)
LDA_t_fea = topic_modeling.load_t_fea(name, "LDA", 20)
results = []
# results.append({'name':'topical_CR','errors':evaluation.evaluate(name, cc.topical_CR(classifier,LTM_t_fea))})
# results.append({'name':'ContentOnly','errors':evaluation.evaluate(name, cc.CO(classifier))})
# results.append({'name':'wvRN_RL','errors':evaluation.evaluate(name, cc.wvRN_RL())})
# results.append({'name':'topical_CO+LDA','errors':evaluation.evaluate(name, cc.topical_CO(classifier, LDA_t_fea))})
results.append(
{"name": "topical_CO+LTM", "errors": evaluation.evaluate(name, cc.topical_CO(classifier, LTM_t_fea))}
)
results.append(
{"name": "topical_CO+LTM", "errors": evaluation.evaluate(name, cc.topical_CO(knn_classifier, LTM_t_fea))}
)
# results.append({'name':'ICA','errors':evaluation.evaluate(name, cc.ICA(classifier))})
# results.append({'name':'semi_ICA','errors':evaluation.evaluate(name, cc.semi_ICA(classifier))})
return results
def run_grid_search(conf_set, format,
cnfs_file, pred_file, grid_file=None,
steps=(10,5),
deep=True):
preds = parse_pred_file(pred_file, format, conf_set)
minmax_params = find_minmax_params(preds)
generator = grid_search_generator(minmax_params, steps, grid_file, deep)
while True:
thrdif = generator.next()
if not thrdif or len(thrdif) == 3:
break
prec, rec, fscore = evaluate(cnfs_file, preds, *thrdif)
generator.send( (prec, rec, fscore) )
while deep:
thrdif = generator.next()
if not thrdif or len(thrdif) == 3:
break
prec, rec, fscore = evaluate(cnfs_file, preds, *thrdif)
generator.send( (prec, rec, fscore) )
return generator.next()
def test_mixed_full_training(test_session):
target = {'LR': 0.82,
'Simple': 18,
'Causal': 4}
all = [models[k].Predictor(test_session, test=True).predict(threshold=v)
for k, v in target.items()]
rv = {}
for r in all:
for k, v in r.items():
rv.setdefault(k, set())
rv[k] |= v
report_data = evaluate(rv)
print(report_static_test(report_data, flag='Full'))
def evaluate_scorer(test_queries, scorer_obj):
"""Rank the candidates and evaluate the result.
:rtype (EvaluationResult, list[EvaluationQuery])
:param test_dataset:
:param config:
:param cached:
:param scorer_obj:
:param num_processes:
:return:
"""
for query in test_queries:
query.eval_candidates = scorer_obj.rank_query_candidates(
query.eval_candidates,
key=lambda x: x.query_candidate)
res, queries = evaluate(test_queries)
return res, queries
def evaluate_scorer_parallel(test_queries, scorer_obj,
num_processes=6):
"""Parallel rank the candidates and evaluate the result.
:rtype (EvaluationResult, list[EvaluationQuery])
:param test_dataset:
:param config:
:param cached:
:param scorer_obj:
:param num_processes:
:return:
"""
re_rank = functools.partial(rank_candidates, ranker=scorer_obj)
pool = mp.Pool(processes=num_processes)
logger.info("Parallelly rescoring candidates.")
queries = pool.map(re_rank, test_queries,
len(test_queries) / num_processes)
pool.close()
logger.info("Evaluating re-scored candidates.")
res, queries = evaluate(queries)
return res, queries
def auto_experiment(MAX_minsup,MIN_minsup,sup_gap,MAX_minlen,MIN_minlen,len_gap):
#open the file to store the results of the experiment
output_file=open("data/evaluation_MAXminsup%d_MINminsup%d_supgap%d_MAXminlen%d_MINminlen%d_lengap%d.txt" %(MAX_minsup,MIN_minsup,sup_gap,MAX_minlen,MIN_minlen,len_gap),"w")
sup=MIN_minsup
while sup<=MAX_minsup:
length=MIN_minlen
while length<=MAX_minlen:
prefixspan_old("tagged_GoodQA_Question.dat","patterns_minsup%d_minlen%d.dat" %(sup,length),sup,False,length)
find_dialogue.find("tagged_subtitle.dat","patterns_minsup%d_minlen%d.dat" %(sup,length),"dialogues_minsup%d_minlen%d.txt" %(sup,length))
(minimal_precision,precision,recall)=evaluation.evaluate("dialogues_minsup%d_minlen%d.txt" %(sup,length),"QA_subtitle.txt","tagdatapos.dat")
output_file.write("\n")
output_file.write("minsup==%d\n" %(sup))
output_file.write("minlen==%d\n" %(length))
output_file.write('minimal_precision='+str(minimal_precision)+'\n')
output_file.write('precision='+str(precision)+'\n')
output_file.write('recall='+str(recall)+'\n')
length=length+len_gap
sup=sup+sup_gap
#close the file
output_file.close()
def evaluate_scorer(test_queries, scorer_obj, print_ranked_candidates=False):
"""Rank the candidates and evaluate the result.
:rtype (EvaluationResult, list[EvaluationQuery])
:param test_dataset:
:param config:
:param cached:
:param scorer_obj:
:param num_processes:
:return:
"""
for index, query in enumerate(test_queries):
query.eval_candidates = scorer_obj.rank_query_candidates(
query.eval_candidates,
key=lambda x: x.query_candidate,
utterance=query.utterance)
if (index + 1) % 100 == 0:
logger.info("%d questions answered" % (index + 1))
res, queries = evaluate(test_queries)
if print_ranked_candidates:
print_candidates(test_queries)
return res, queries
def run_and_output_model(X, y, model, obj_inds,
train_inds, test_inds,
eval_params, other_params,
stopword_test_inds):
X_train = X[train_inds, :]
y_train = y[train_inds]
X_test = X[test_inds, :]
y_test = y[test_inds]
model = model.fit(X_train,y_train)
if X_test.shape[0] == 0:
return [], model, []
predicted_prob = model.predict_proba(X_test)
ret_dat = []
stopword_test_inds_0 = []
stopword_test_inds_1 = []
for x in stopword_test_inds:
if y[x] == 1:
stopword_test_inds_1.append(x)
else:
stopword_test_inds_0.append(x)
if len(stopword_test_inds):
extra_tn = len(stopword_test_inds_0)
extra_fn = len(stopword_test_inds_1)
y_test = np.concatenate((y_test,np.array([0]*extra_tn),np.array([1]*extra_fn)),axis=0)
predicted_prob = np.concatenate((predicted_prob,[[1,0]]*(extra_tn+extra_fn)),axis=0)
test_inds = test_inds + stopword_test_inds_0 + stopword_test_inds_1
for p in eval_params:
o = evaluate(p, y_test, predicted_prob,obj_inds,test_inds,print_eval=False)
ret_dat.append(other_params+o)
return ret_dat, model, predicted_prob
def main():
args = get_args()
torch.manual_seed(args.seed)
torch.cuda.manual_seed_all(args.seed)
if args.cuda and torch.cuda.is_available() and args.cuda_deterministic:
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True
log_dir = os.path.expanduser(args.log_dir)
eval_log_dir = log_dir + "_eval"
utils.cleanup_log_dir(log_dir)
utils.cleanup_log_dir(eval_log_dir)
torch.set_num_threads(1)
device = torch.device("cuda:0" if args.cuda else "cpu")
envs = make_vec_envs(args.env_name, args.seed, args.num_processes,
args.gamma, args.log_dir, device, False)
actor_critic = Policy(envs.observation_space.shape,
envs.action_space,
base_kwargs={'recurrent': args.recurrent_policy})
actor_critic.to(device)
if args.algo == 'a2c':
agent = algo.A2C_ACKTR(actor_critic,
args.value_loss_coef,
args.entropy_coef,
lr=args.lr,
eps=args.eps,
alpha=args.alpha,
max_grad_norm=args.max_grad_norm)
elif args.algo == 'ppo':
agent = algo.PPO(actor_critic,
args.clip_param,
args.ppo_epoch,
args.num_mini_batch,
args.value_loss_coef,
args.entropy_coef,
lr=args.lr,
eps=args.eps,
max_grad_norm=args.max_grad_norm)
elif args.algo == 'acktr':
agent = algo.A2C_ACKTR(actor_critic,
args.value_loss_coef,
args.entropy_coef,
acktr=True)
if args.gail:
assert len(envs.observation_space.shape) == 1
discr = gail.Discriminator(
envs.observation_space.shape[0] + envs.action_space.shape[0], 100,
device)
file_name = os.path.join(
args.gail_experts_dir,
"trajs_{}.pt".format(args.env_name.split('-')[0].lower()))
expert_dataset = gail.ExpertDataset(file_name,
num_trajectories=4,
subsample_frequency=20)
drop_last = len(expert_dataset) > args.gail_batch_size
gail_train_loader = torch.utils.data.DataLoader(
dataset=expert_dataset,
batch_size=args.gail_batch_size,
shuffle=True,
drop_last=drop_last)
rollouts = RolloutStorage(args.num_steps, args.num_processes,
envs.observation_space.shape, envs.action_space,
actor_critic.recurrent_hidden_state_size)
obs = envs.reset()
rollouts.obs[0].copy_(obs)
rollouts.to(device)
episode_rewards = deque(maxlen=10)
start = time.time()
num_updates = int(
args.num_env_steps) // args.num_steps // args.num_processes
for j in range(num_updates):
if args.use_linear_lr_decay:
# decrease learning rate linearly
utils.update_linear_schedule(
agent.optimizer, j, num_updates,
agent.optimizer.lr if args.algo == "acktr" else args.lr)
for step in range(args.num_steps):
# Sample actions
with torch.no_grad():
value, action, action_log_prob, recurrent_hidden_states = actor_critic.act(
rollouts.obs[step], rollouts.recurrent_hidden_states[step],
rollouts.masks[step])
# Obser reward and next obs
obs, reward, done, infos = envs.step(action)
for info in infos:
if 'episode' in info.keys():
episode_rewards.append(info['episode']['r'])
# If done then clean the history of observations.
masks = torch.FloatTensor([[0.0] if done_ else [1.0]
for done_ in done])
bad_masks = torch.FloatTensor(
[[0.0] if 'bad_transition' in info.keys() else [1.0]
for info in infos])
rollouts.insert(obs, recurrent_hidden_states, action,
action_log_prob, value, reward, masks, bad_masks)
with torch.no_grad():
next_value = actor_critic.get_value(
rollouts.obs[-1], rollouts.recurrent_hidden_states[-1],
rollouts.masks[-1]).detach()
if args.gail:
if j >= 10:
envs.venv.eval()
gail_epoch = args.gail_epoch
if j < 10:
gail_epoch = 100 # Warm up
for _ in range(gail_epoch):
discr.update(gail_train_loader, rollouts,
utils.get_vec_normalize(envs)._obfilt)
for step in range(args.num_steps):
rollouts.rewards[step] = discr.predict_reward(
rollouts.obs[step], rollouts.actions[step], args.gamma,
rollouts.masks[step])
rollouts.compute_returns(next_value, args.use_gae, args.gamma,
args.gae_lambda, args.use_proper_time_limits)
value_loss, action_loss, dist_entropy = agent.update(rollouts)
rollouts.after_update()
# save for every interval-th episode or for the last epoch
if (j % args.save_interval == 0
or j == num_updates - 1) and args.save_dir != "":
save_path = os.path.join(args.save_dir, args.algo)
try:
os.makedirs(save_path)
except OSError:
pass
torch.save([
actor_critic,
getattr(utils.get_vec_normalize(envs), 'ob_rms', None)
], os.path.join(save_path, args.env_name + ".pt"))
if j % args.log_interval == 0 and len(episode_rewards) > 1:
total_num_steps = (j + 1) * args.num_processes * args.num_steps
end = time.time()
print(
"Updates {}, num timesteps {}, FPS {} \n Last {} training episodes: mean/median reward {:.1f}/{:.1f}, min/max reward {:.1f}/{:.1f}\n"
.format(j, total_num_steps,
int(total_num_steps / (end - start)),
len(episode_rewards), np.mean(episode_rewards),
np.median(episode_rewards), np.min(episode_rewards),
np.max(episode_rewards), dist_entropy, value_loss,
action_loss))
if (args.eval_interval is not None and len(episode_rewards) > 1
and j % args.eval_interval == 0):
ob_rms = utils.get_vec_normalize(envs).ob_rms
evaluate(actor_critic, ob_rms, args.env_name, args.seed,
args.num_processes, eval_log_dir, device)
def main():
train_log = Log(log_name + '_train_log')
evl_log = Log(log_name + '_evaluation_log')
torch.set_num_threads(1)
envs = make_vec_envs(args_env_name, args_seed, args_num_processes)
envs.action_space.n = 3
# print(envs.action_space.n)
# print(envs.action_space)
# ss('hohoho')
actor_critic = Policy(envs.observation_space.shape, envs.action_space)
agent = PPO(actor_critic,
args_clip_param,
args_ppo_epoch,
args_num_mini_batch,
args_value_loss_coef,
args_entropy_coef,
lr=args_lr,
eps=args_eps,
max_grad_norm=args_max_grad_norm)
rollouts = RolloutStorage(args_num_steps, args_num_processes,
envs.observation_space.shape, envs.action_space)
obs = envs.reset()
rollouts.obs[0].copy_(obs)
# print(obs)
# ss('i am over it')
num_updates = int(
args_num_env_steps) // args_num_steps // args_num_processes
episode_rewards = deque(maxlen=10)
start = time.time()
sum_re = torch.zeros(args_num_processes, 1)
for j in range(num_updates):
for step in range(args_num_steps):
with torch.no_grad():
value, action, action_log_prob\
= actor_critic.act(rollouts.obs[step])
# print(action)
# print()
# action = action + 1
# print(action)
# ss('hoiohasdfhioas')
obs, reward, done, infos = envs.step(action + 1)
sum_re += reward
if any(done):
for i in range(len(done)):
if done[i]:
episode_rewards.append(sum_re[i].item())
# print(done)
# print(sum_re[i])
sum_re[i] *= 0
masks = torch.FloatTensor([[0.0] if done_ else [1.0]
for done_ in done])
bad_masks = torch.FloatTensor(
[[0.0] if 'bad_transition' in info.keys() else [1.0]
for info in infos])
rollouts.insert(obs, action, action_log_prob, value, reward, masks,
bad_masks)
with torch.no_grad():
next_value = actor_critic.get_value(rollouts.obs[-1])
rollouts.compute_returns(next_value, args_gamma)
value_loss, action_loss, dist_entropy = agent.update(rollouts)
rollouts.after_update()
if j % args_log_interval == 0 and len(episode_rewards) > 1:
total_num_steps = (j + 1) * args_num_processes * args_num_steps
end = time.time()
logstring = "E {}, N_steps {}, FPS {} mean/median" \
" {:.1f}/{:.1f}, min/max {:.1f}/{:.1f}" \
" Entropy {:.5f},V {:.5f},Action {:.5f}".format(
j, total_num_steps,
int(total_num_steps / (end - start)),
np.mean(episode_rewards),
np.median(episode_rewards), np.min(episode_rewards),
np.max(episode_rewards),
dist_entropy, value_loss,
action_loss)
# print(logstring)
train_log.log(logstring)
# if True:
if (args_eval_interval is not None and len(episode_rewards) > 1
and j % args_eval_interval == 0):
total_num_steps = (j + 1) * args_num_processes * args_num_steps
ob_rms = get_vec_normalize(envs).ob_rms
ev_result = evaluate(actor_critic, ob_rms, args_env_name,
args_seed, args_num_processes)
ev_log_string = 'steps:' + str(total_num_steps) + '. ' + ev_result
evl_log.log(ev_log_string)
model.train()
image, mask, gt = [x.to(device) for x in next(iterator_train)]
#print(image.shape)
#print(mask.shape)
#print(gt.shape)
output, _ = model(image, mask)
loss_dict = criterion(image, mask, output, gt)
loss = 0.0
for key, coef in opt.LAMBDA_DICT.items():
value = coef * loss_dict[key]
loss += value
if (i + 1) % args.log_interval == 0:
writer.add_scalar('loss_{:s}'.format(key), value.item(), i + 1)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (i + 1) % args.save_model_interval == 0 or (i + 1) == args.max_iter:
save_ckpt('{:s}/ckpt/{:d}.pth'.format(args.save_dir, i + 1),
[('model', model)], [('optimizer', optimizer)], i + 1)
if (i + 1) % args.vis_interval == 0:
model.eval()
evaluate(model, dataset_val, device,
'{:s}/images/test_{:d}.jpg'.format(args.save_dir, i + 1))
writer.close()
test = user_item_test.groupby('user_ix').resource_id.apply(
lambda x: list(x))
if not os.path.exists('idea1_models'):
os.makedirs('idea1_models')
model, history = nn_train(user_item_train,
user_item_test[user_item_test['user_ix'].isin(
test.index)],
user_embedding=user_embedding,
article_embedding=article_embedding,
new=True,
model_params=model_params,
model_path='idea1_models/timewise_sampling',
last_x_articles=1000)
test = test.head(10000)
train_grouped = user_item_train[user_item_train['user_ix'].isin(
test.index)].groupby('user_ix').resource_id.apply(lambda x: list(x))
pred, raw = prediction(model,
user_embedding.loc[test.index],
article_embedding,
train_grouped,
N,
model_params=model_params)
pred = pred[pred.index.isin(test.index)]
idea1 = evaluate(pred.sort_index(),
test.sort_index(),
experiment_name='idea1_timewise_sampling.results',
limit=limit)
#!/usr/bin/env python
import os
import sys
os.environ['GLOG_minloglevel'] = '1'
import caffe
import net
import evaluation
import config
if __name__ == '__main__':
args = sys.argv[1:]
net_path = args[0]
db_path = args[1]
snapshot_folder = args[2]
results_folder = args[3]
if len(args) > 4:
every_iter = int(args[4])
else:
every_iter = None
caffe.set_mode_gpu()
net = net.DropoutNet(net_path, config.DROPOUT_ITERS, aggregate='mean', output_layers=config.OUTPUT_LAYERS)
evaluation = evaluation.NetEvaluation(net, db_path, snapshot_folder, results_folder, every_iter)
evaluation.evaluate()
print()
epoch_train_time_list = []
training_losses = []
validate_accuracies = []
for i in range(epochs):
t1 = time()
X_TRAIN, Y_TRAIN = shuffle(X_TRAIN, Y_TRAIN)
for offset in range(0, num_examples, batch_size):
end = offset + batch_size
batch_x, batch_y = X_TRAIN[offset:end], Y_TRAIN[offset:end]
_, loss = sess.run((TRAIN_OPERATION, LOSS_OPERATION), \
feed_dict={FEATURES: batch_x, LABELS: batch_y, KEEP_PROB: 0.5})
if TRAIN_RATIO < 1.0:
_, validation_accuracy = evaluate(X_VALID, Y_VALID, LOGITS, SOFTMAX, \
batch_size)
else:
validation_accuracy = None
print("EPOCH {} ...".format(i+1))
print("Training Loss = {:.3f}".format(loss))
if validation_accuracy is not None:
print("Validation Accuracy = {:.3f}".format(validation_accuracy))
print()
epoch_train_time_list.append(time() - t1)
training_losses.append(loss)
validate_accuracies.append(validation_accuracy)
SAVER.save(sess, SAVE_FILE)
print("Model saved")
log_run_end(run_id, validation_accuracy, loss)
print()
def train(args):
"""Maximum Likelihood Estimation"""
grammar = ASDLGrammar.from_text(open(args.asdl_file).read())
transition_system = TransitionSystem.get_class_by_lang(args.lang)(grammar)
train_set = Dataset.from_bin_file(args.train_file)
if args.dev_file:
dev_set = Dataset.from_bin_file(args.dev_file)
else: dev_set = Dataset(examples=[])
vocab = pickle.load(open(args.vocab, 'rb'))
if args.lang == 'wikisql':
# import additional packages for wikisql dataset
from model.wikisql.dataset import WikiSqlExample, WikiSqlTable, TableColumn
parser_cls = get_parser_class(args.lang)
model = parser_cls(args, vocab, transition_system)
model.train()
if args.cuda: model.cuda()
optimizer_cls = eval('torch.optim.%s' % args.optimizer) # FIXME: this is evil!
optimizer = optimizer_cls(model.parameters(), lr=args.lr)
if args.uniform_init:
print('uniformly initialize parameters [-%f, +%f]' % (args.uniform_init, args.uniform_init), file=sys.stderr)
nn_utils.uniform_init(-args.uniform_init, args.uniform_init, model.parameters())
elif args.glorot_init:
print('use glorot initialization', file=sys.stderr)
nn_utils.glorot_init(model.parameters())
# load pre-trained word embedding (optional)
if args.glove_embed_path:
print('load glove embedding from: %s' % args.glove_embed_path, file=sys.stderr)
glove_embedding = GloveHelper(args.glove_embed_path)
glove_embedding.load_to(model.src_embed, vocab.source)
print('begin training, %d training examples, %d dev examples' % (len(train_set), len(dev_set)), file=sys.stderr)
print('vocab: %s' % repr(vocab), file=sys.stderr)
epoch = train_iter = 0
report_loss = report_examples = report_sup_att_loss = 0.
history_dev_scores = []
num_trial = patience = 0
while True:
epoch += 1
epoch_begin = time.time()
for batch_examples in train_set.batch_iter(batch_size=args.batch_size, shuffle=True):
batch_examples = [e for e in batch_examples if len(e.tgt_actions) <= args.decode_max_time_step]
train_iter += 1
optimizer.zero_grad()
ret_val = model.score(batch_examples)
loss = -ret_val[0]
# print(loss.data)
loss_val = torch.sum(loss).data[0]
report_loss += loss_val
report_examples += len(batch_examples)
loss = torch.mean(loss)
if args.sup_attention:
att_probs = ret_val[1]
if att_probs:
sup_att_loss = -torch.log(torch.cat(att_probs)).mean()
sup_att_loss_val = sup_att_loss.data[0]
report_sup_att_loss += sup_att_loss_val
loss += sup_att_loss
loss.backward()
# clip gradient
if args.clip_grad > 0.:
grad_norm = torch.nn.utils.clip_grad_norm(model.parameters(), args.clip_grad)
optimizer.step()
if train_iter % args.log_every == 0:
log_str = '[Iter %d] encoder loss=%.5f' % (train_iter, report_loss / report_examples)
if args.sup_attention:
log_str += ' supervised attention loss=%.5f' % (report_sup_att_loss / report_examples)
report_sup_att_loss = 0.
print(log_str, file=sys.stderr)
report_loss = report_examples = 0.
print('[Epoch %d] epoch elapsed %ds' % (epoch, time.time() - epoch_begin), file=sys.stderr)
if args.save_all_models:
model_file = args.save_to + '.iter%d.bin' % train_iter
print('save model to [%s]' % model_file, file=sys.stderr)
model.save(model_file)
# perform validation
if args.dev_file:
if epoch % args.valid_every_epoch == 0:
print('[Epoch %d] begin validation' % epoch, file=sys.stderr)
eval_start = time.time()
eval_results = evaluation.evaluate(dev_set.examples, model, args,
verbose=True, eval_top_pred_only=args.eval_top_pred_only)
dev_acc = eval_results['accuracy']
print('[Epoch %d] code generation accuracy=%.5f took %ds' % (epoch, dev_acc, time.time() - eval_start), file=sys.stderr)
is_better = history_dev_scores == [] or dev_acc > max(history_dev_scores)
history_dev_scores.append(dev_acc)
else:
is_better = True
if epoch > args.lr_decay_after_epoch:
lr = optimizer.param_groups[0]['lr'] * args.lr_decay
print('decay learning rate to %f' % lr, file=sys.stderr)
# set new lr
for param_group in optimizer.param_groups:
param_group['lr'] = lr
if is_better:
patience = 0
model_file = args.save_to + '.bin'
print('save the current model ..', file=sys.stderr)
print('save model to [%s]' % model_file, file=sys.stderr)
model.save(model_file)
# also save the optimizers' state
torch.save(optimizer.state_dict(), args.save_to + '.optim.bin')
elif patience < args.patience and epoch >= args.lr_decay_after_epoch:
patience += 1
print('hit patience %d' % patience, file=sys.stderr)
if epoch == args.max_epoch:
print('reached max epoch, stop!', file=sys.stderr)
exit(0)
if patience >= args.patience and epoch >= args.lr_decay_after_epoch:
num_trial += 1
print('hit #%d trial' % num_trial, file=sys.stderr)
if num_trial == args.max_num_trial:
print('early stop!', file=sys.stderr)
exit(0)
# decay lr, and restore from previously best checkpoint
lr = optimizer.param_groups[0]['lr'] * args.lr_decay
print('load previously best model and decay learning rate to %f' % lr, file=sys.stderr)
# load model
params = torch.load(args.save_to + '.bin', map_location=lambda storage, loc: storage)
model.load_state_dict(params['state_dict'])
if args.cuda: model = model.cuda()
# load optimizers
if args.reset_optimizer:
print('reset optimizer', file=sys.stderr)
optimizer = torch.optim.Adam(model.parameters(), lr=lr)
else:
print('restore parameters of the optimizers', file=sys.stderr)
optimizer.load_state_dict(torch.load(args.save_to + '.optim.bin'))
# set new lr
for param_group in optimizer.param_groups:
param_group['lr'] = lr
# reset patience
patience = 0
def test_gcn_v(model, cfg, logger):
for k, v in cfg.model['kwargs'].items():
setattr(cfg.test_data, k, v)
dataset = build_dataset(cfg.model['type'], cfg.test_data)
folder = '{}_gcnv_k_{}_th_{}'.format(cfg.test_name, cfg.knn, cfg.th_sim)
oprefix = osp.join(cfg.work_dir, folder)
oname = osp.basename(rm_suffix(cfg.load_from))
opath_pred_confs = osp.join(oprefix, 'pred_confs', '{}.npz'.format(oname))
if osp.isfile(opath_pred_confs) and not cfg.force:
data = np.load(opath_pred_confs)
pred_confs = data['pred_confs']
inst_num = data['inst_num']
if inst_num != dataset.inst_num:
logger.warn(
'instance number in {} is different from dataset: {} vs {}'.
format(opath_pred_confs, inst_num, len(dataset)))
else:
pred_confs, gcn_feat = test(model, dataset, cfg, logger)
inst_num = dataset.inst_num
logger.info('pred_confs: mean({:.4f}). max({:.4f}), min({:.4f})'.format(
pred_confs.mean(), pred_confs.max(), pred_confs.min()))
logger.info('Convert to cluster')
with Timer('Predition to peaks'):
pred_dist2peak, pred_peaks = confidence_to_peaks(
dataset.dists, dataset.nbrs, pred_confs, cfg.max_conn)
if not dataset.ignore_label and cfg.eval_interim:
# evaluate the intermediate results
for i in range(cfg.max_conn):
num = len(dataset.peaks)
pred_peaks_i = np.arange(num)
peaks_i = np.arange(num)
for j in range(num):
if len(pred_peaks[j]) > i:
pred_peaks_i[j] = pred_peaks[j][i]
if len(dataset.peaks[j]) > i:
peaks_i[j] = dataset.peaks[j][i]
acc = accuracy(pred_peaks_i, peaks_i)
logger.info('[{}-th conn] accuracy of peak match: {:.4f}'.format(
i + 1, acc))
acc = 0.
for idx, peak in enumerate(pred_peaks_i):
acc += int(dataset.idx2lb[peak] == dataset.idx2lb[idx])
acc /= len(pred_peaks_i)
logger.info(
'[{}-th conn] accuracy of peak label match: {:.4f}'.format(
i + 1, acc))
with Timer('Peaks to clusters (th_cut={})'.format(cfg.tau_0)):
pred_labels = peaks_to_labels(pred_peaks, pred_dist2peak, cfg.tau_0,
inst_num)
if cfg.save_output:
logger.info('save predicted confs to {}'.format(opath_pred_confs))
mkdir_if_no_exists(opath_pred_confs)
np.savez_compressed(opath_pred_confs,
pred_confs=pred_confs,
inst_num=inst_num)
# save clustering results
idx2lb = list2dict(pred_labels, ignore_value=-1)
opath_pred_labels = osp.join(
cfg.work_dir, folder, 'tau_{}_pred_labels.txt'.format(cfg.tau_0))
logger.info('save predicted labels to {}'.format(opath_pred_labels))
mkdir_if_no_exists(opath_pred_labels)
write_meta(opath_pred_labels, idx2lb, inst_num=inst_num)
# evaluation
if not dataset.ignore_label:
print('==> evaluation')
for metric in cfg.metrics:
evaluate(dataset.gt_labels, pred_labels, metric)
if cfg.use_gcn_feat:
# gcn_feat is saved to disk for GCN-E
opath_feat = osp.join(oprefix, 'features', '{}.bin'.format(oname))
if not osp.isfile(opath_feat) or cfg.force:
mkdir_if_no_exists(opath_feat)
write_feat(opath_feat, gcn_feat)
name = rm_suffix(osp.basename(opath_feat))
prefix = oprefix
ds = BasicDataset(name=name,
prefix=prefix,
dim=cfg.model['kwargs']['nhid'],
normalize=True)
ds.info()
# use top embedding of GCN to rebuild the kNN graph
with Timer('connect to higher confidence with use_gcn_feat'):
knn_prefix = osp.join(prefix, 'knns', name)
knns = build_knns(knn_prefix,
ds.features,
cfg.knn_method,
cfg.knn,
is_rebuild=True)
dists, nbrs = knns2ordered_nbrs(knns)
pred_dist2peak, pred_peaks = confidence_to_peaks(
dists, nbrs, pred_confs, cfg.max_conn)
pred_labels = peaks_to_labels(pred_peaks, pred_dist2peak, cfg.tau,
inst_num)
# save clustering results
if cfg.save_output:
oname_meta = '{}_gcn_feat'.format(name)
opath_pred_labels = osp.join(
oprefix, oname_meta, 'tau_{}_pred_labels.txt'.format(cfg.tau))
mkdir_if_no_exists(opath_pred_labels)
idx2lb = list2dict(pred_labels, ignore_value=-1)
write_meta(opath_pred_labels, idx2lb, inst_num=inst_num)
# evaluation
if not dataset.ignore_label:
print('==> evaluation')
for metric in cfg.metrics:
evaluate(dataset.gt_labels, pred_labels, metric)
import json
import os
import pdb
pdb.set_trace()
img_labels = json.load(
open(r'/home/finn/research/data/clustering_data/test_index.json',
'r',
encoding='utf-8'))
import shutil
output = r'/home/finn/research/data/clustering_data/mr_gcn_output'
for label in set(pred_labels):
if not os.path.exists(os.path.join(output, f'cluter_{label}')):
os.mkdir(os.path.join(output, f'cluter_{label}'))
for image in img_labels:
shutil.copy2(
image,
os.path.join(
os.path.join(output,
f'cluter_{pred_labels[img_labels[image]]}'),
os.path.split(image)[-1]))
def train_basic(plot=False):
# Data loading
train_path = "train.labeled"
test_path = "test.labeled"
train_sentences_df = split(train_path)
test_sentences_df = split(test_path)
word_to_ix, tag_to_ix, _ = generateVocabs(train_sentences_df)
train = KiperwasserDataset(word_to_ix,
tag_to_ix,
train_sentences_df,
tp='train_')
train_dataloader = DataLoader(train, shuffle=True)
test = KiperwasserDataset(word_to_ix,
tag_to_ix,
test_sentences_df,
tp='test')
test_dataloader = DataLoader(test, shuffle=False)
word_vocab_size = len(train.word_to_ix)
tag_vocab_size = len(train.tag_to_ix)
loss_function = nn.CrossEntropyLoss() # NLLLoss
use_cuda = torch.cuda.is_available()
device = torch.device("cuda:0" if use_cuda else "cpu")
model = emptyModel(word_vocab_size, tag_vocab_size)
if use_cuda:
model.cuda()
optimizer = optim.Adam(model.parameters(), lr=0.01)
# Training start
print("Training Started")
UAS_train_list = []
UAS_test_list = []
loss_list = []
epochs = EPOCHS
best_UAS_sf = 0.84
for epoch in range(epochs):
current_loss = 0 # To keep track of the loss value
i = 0
for input_data in train_dataloader:
model.train() # put model on train model to procceed with dropout
i += 1
words_idx_tensor, pos_idx_tensor, gold = input_data
gold = gold.squeeze(0).to(device)
scores = model(words_idx_tensor, pos_idx_tensor, gold)
loss = loss_function(scores[1:, :], gold[1:])
loss = loss / accumulate_grad_steps
loss.backward()
if i % accumulate_grad_steps == 0:
optimizer.step()
model.zero_grad()
current_loss += loss.item()
# below used for plotting
current_loss = current_loss / len(train)
loss_list.append(float(current_loss))
UAS_train = evaluation.evaluate(train_dataloader, model)
UAS_test = evaluation.evaluate(test_dataloader, model)
UAS_train_list.append(UAS_train)
UAS_test_list.append(UAS_test)
if UAS_test > best_UAS_sf:
model.save('basic_final_' + str(epoch))
best_UAS_sf = UAS_test
plot_figures(loss_list, UAS_train_list, UAS_test_list,
'basic_' + str(epoch))
print(
f"Epoch {epoch + 1}, \tLoss: {current_loss:.7f}, \t UAS_train: {UAS_train:.4f}, \tUAS_test: {UAS_test:.4f}"
)
if plot:
plot_figures(loss_list, UAS_train_list, UAS_test_list, 'basic')
return model
dtc = tree.DecisionTreeClassifier(max_depth=int(sys.argv[1]))
print("training...")
start = time.time()
dtc.fit(train.iloc[:, :-2], train.iloc[:, -1])
end = time.time()
ttf = (end - start)
print("testing...")
start = time.time()
y_dtc = dtc.predict(test.iloc[:, :-2])
end = time.time()
ttp = (end - start)
print("evaluating...")
evaluate(y_dtc, test.iloc[:, -1])
print("ttf = \t\t", ttf)
print("ttp = \t\t", ttp)
dot_data = tree.export_graphviz(dtc,
out_file=None,
feature_names=train.columns[:-2],
class_names=['normal', 'attack'],
filled=True,
special_characters=True)
graph = graphviz.Source(dot_data)
graph.render("./results/dtc_clf_md" + str(sys.argv[1]) + "_all_features")
def main(argv):
del argv # Unused.
# Configure parameters.
config = mask_rcnn_params.default_config()
config = params_io.override_hparams(config, FLAGS.config)
if FLAGS.use_tpu:
tpu_cluster_resolver = tf.contrib.cluster_resolver.TPUClusterResolver(
FLAGS.tpu, zone=FLAGS.tpu_zone, project=FLAGS.gcp_project)
tpu_grpc_url = tpu_cluster_resolver.get_master()
tf.Session.reset(tpu_grpc_url)
else:
tpu_cluster_resolver = None
# Check data path
if (FLAGS.mode in ('train', 'train_and_eval')
and not config.training_file_pattern):
raise RuntimeError(
'You must specify `training_file_pattern` for training.')
if FLAGS.mode in ('eval', 'train_and_eval'):
if not config.validation_file_pattern:
raise RuntimeError('You must specify `validation_file_pattern` '
'for evaluation.')
if not config.val_json_file:
raise RuntimeError(
'You must specify `val_json_file` for evaluation.')
# The following is for spatial partitioning. `features` has one tensor while
# `labels` has 4 + (`max_level` - `min_level` + 1) * 2 tensors. The input
# partition is performed on `features` and all partitionable tensors of
# `labels`, see the partition logic below.
# Note: In the below code, TPUEstimator uses both `shard` and `replica` (with
# the same meaning).
if FLAGS.input_partition_dims:
labels_partition_dims = {
'gt_boxes': None,
'gt_classes': None,
'cropped_gt_masks': None,
}
# TODO(b/119617317): The Input Partition Logic. We partition only the
# partition-able tensors. Spatial partition requires that the
# to-be-partitioned tensors must have a dimension that is a multiple of
# `partition_dims`. Depending on the `partition_dims` and the `image_size`
# and the `max_level` in config, some high-level anchor labels (i.e.,
# `cls_targets` and `box_targets`) cannot be partitioned. For example, when
# `partition_dims` is [1, 4, 2, 1], image size is 1536, `max_level` is 9,
# `cls_targets_8` has a shape of [batch_size, 6, 6, 9], which cannot be
# partitioned (6 % 4 != 0). In this case, the level-8 and level-9 target
# tensors are not partition-able, and the highest partition-able level is 7.
image_size = config.image_size
for level in range(config.min_level, config.max_level + 1):
def _can_partition(spatial_dim):
partitionable_index = np.where(
spatial_dim % np.array(FLAGS.input_partition_dims) == 0)
return len(partitionable_index[0]) == len(
FLAGS.input_partition_dims)
assert len(image_size) == 2
spatial_dim = [d // (2**level) for d in image_size]
if _can_partition(spatial_dim[0]) and _can_partition(
spatial_dim[1]):
labels_partition_dims['box_targets_%d' %
level] = FLAGS.input_partition_dims
labels_partition_dims['score_targets_%d' %
level] = FLAGS.input_partition_dims
else:
labels_partition_dims['box_targets_%d' % level] = None
labels_partition_dims['score_targets_%d' % level] = None
num_cores_per_replica = np.prod(FLAGS.input_partition_dims)
image_partition_dims = [
FLAGS.input_partition_dims[i] for i in [1, 2, 3, 0]
] if FLAGS.transpose_input else FLAGS.input_partition_dims
features_partition_dims = {
'images': image_partition_dims,
'source_ids': None,
'image_info': None,
}
input_partition_dims = [features_partition_dims, labels_partition_dims]
num_shards = FLAGS.num_cores // num_cores_per_replica
else:
num_cores_per_replica = None
input_partition_dims = None
num_shards = FLAGS.num_cores
params = dict(
config.values(),
num_shards=num_shards,
use_tpu=FLAGS.use_tpu,
mode=FLAGS.mode,
# The following are used by the host_call function.
model_dir=FLAGS.model_dir,
iterations_per_loop=FLAGS.iterations_per_loop,
transpose_input=FLAGS.transpose_input)
tpu_config = tf.contrib.tpu.TPUConfig(
FLAGS.iterations_per_loop,
num_shards=num_shards,
num_cores_per_replica=num_cores_per_replica,
input_partition_dims=input_partition_dims,
per_host_input_for_training=tf.contrib.tpu.InputPipelineConfig.
PER_HOST_V2)
run_config = tf.contrib.tpu.RunConfig(
cluster=tpu_cluster_resolver,
evaluation_master=FLAGS.eval_master,
model_dir=FLAGS.model_dir,
log_step_count_steps=FLAGS.iterations_per_loop,
tpu_config=tpu_config,
)
if FLAGS.mode == 'train':
if FLAGS.model_dir:
save_config(config, FLAGS.model_dir)
tf.logging.info(params)
train_estimator = tf.contrib.tpu.TPUEstimator(
model_fn=mask_rcnn_model.mask_rcnn_model_fn,
use_tpu=FLAGS.use_tpu,
train_batch_size=config.train_batch_size,
config=run_config,
params=params)
train_estimator.train(input_fn=dataloader.InputReader(
config.training_file_pattern,
mode=tf.estimator.ModeKeys.TRAIN,
use_fake_data=FLAGS.use_fake_data,
use_instance_mask=config.include_mask),
max_steps=config.total_steps)
if FLAGS.eval_after_training:
# Run evaluation after training finishes.
eval_params_dict = dict(
params,
use_tpu=FLAGS.use_tpu,
input_rand_hflip=False,
is_training_bn=False,
transpose_input=False,
)
eval_estimator = tf.contrib.tpu.TPUEstimator(
model_fn=mask_rcnn_model.mask_rcnn_model_fn,
use_tpu=FLAGS.use_tpu,
train_batch_size=config.train_batch_size,
eval_batch_size=config.eval_batch_size,
predict_batch_size=config.eval_batch_size,
config=run_config,
params=eval_params_dict)
output_dir = os.path.join(FLAGS.model_dir, 'eval')
tf.gfile.MakeDirs(output_dir)
# Summary writer writes out eval metrics.
summary_writer = tf.summary.FileWriter(output_dir)
eval_results = evaluation.evaluate(eval_estimator,
config.validation_file_pattern,
config.eval_samples,
config.eval_batch_size,
config.include_mask,
config.val_json_file)
evaluation.write_summary(eval_results, summary_writer,
config.total_steps)
summary_writer.close()
elif FLAGS.mode == 'eval':
output_dir = os.path.join(FLAGS.model_dir, 'eval')
tf.gfile.MakeDirs(output_dir)
# Summary writer writes out eval metrics.
summary_writer = tf.summary.FileWriter(output_dir)
eval_params_dict = dict(
params,
use_tpu=FLAGS.use_tpu,
input_rand_hflip=False,
is_training_bn=False,
transpose_input=False,
)
eval_estimator = tf.contrib.tpu.TPUEstimator(
model_fn=mask_rcnn_model.mask_rcnn_model_fn,
use_tpu=FLAGS.use_tpu,
train_batch_size=config.train_batch_size,
eval_batch_size=config.eval_batch_size,
predict_batch_size=config.eval_batch_size,
config=run_config,
params=eval_params_dict)
def terminate_eval():
tf.logging.info(
'Terminating eval after %d seconds of no checkpoints' %
FLAGS.eval_timeout)
return True
# Run evaluation when there's a new checkpoint
for ckpt in tf.contrib.training.checkpoints_iterator(
FLAGS.model_dir,
min_interval_secs=FLAGS.min_eval_interval,
timeout=FLAGS.eval_timeout,
timeout_fn=terminate_eval):
# Terminate eval job when final checkpoint is reached
current_step = int(os.path.basename(ckpt).split('-')[1])
tf.logging.info('Starting to evaluate.')
try:
eval_results = evaluation.evaluate(
eval_estimator, config.validation_file_pattern,
config.eval_samples, config.eval_batch_size,
config.include_mask, config.val_json_file)
evaluation.write_summary(eval_results, summary_writer,
config.total_steps)
if current_step >= config.total_steps:
tf.logging.info(
'Evaluation finished after training step %d' %
current_step)
break
except tf.errors.NotFoundError:
# Since the coordinator is on a different job than the TPU worker,
# sometimes the TPU worker does not finish initializing until long after
# the CPU job tells it to start evaluating. In this case, the checkpoint
# file could have been deleted already.
tf.logging.info(
'Checkpoint %s no longer exists, skipping checkpoint' %
ckpt)
summary_writer.close()
# Export saved model.
eval_estimator.export_saved_model(
export_dir_base=FLAGS.model_dir,
serving_input_receiver_fn=functools.partial(
serving_inputs.serving_input_fn,
batch_size=1,
desired_image_size=config.image_size,
padding_stride=(2**config.max_level),
input_type='image_bytes'))
elif FLAGS.mode == 'train_and_eval':
if FLAGS.model_dir:
save_config(config, FLAGS.model_dir)
output_dir = os.path.join(FLAGS.model_dir, 'eval')
tf.gfile.MakeDirs(output_dir)
summary_writer = tf.summary.FileWriter(output_dir)
train_estimator = tf.contrib.tpu.TPUEstimator(
model_fn=mask_rcnn_model.mask_rcnn_model_fn,
use_tpu=FLAGS.use_tpu,
train_batch_size=config.train_batch_size,
config=run_config,
params=params)
eval_params_dict = dict(
params,
use_tpu=FLAGS.use_tpu,
input_rand_hflip=False,
is_training_bn=False,
)
eval_estimator = tf.contrib.tpu.TPUEstimator(
model_fn=mask_rcnn_model.mask_rcnn_model_fn,
use_tpu=FLAGS.use_tpu,
train_batch_size=config.train_batch_size,
eval_batch_size=config.eval_batch_size,
predict_batch_size=config.eval_batch_size,
config=run_config,
params=eval_params_dict)
num_cycles = int(config.total_steps / config.num_steps_per_eval)
for cycle in range(num_cycles):
tf.logging.info('Start training cycle %d.' % cycle)
train_estimator.train(input_fn=dataloader.InputReader(
config.training_file_pattern,
mode=tf.estimator.ModeKeys.TRAIN,
use_instance_mask=config.include_mask),
steps=config.num_steps_per_eval)
tf.logging.info('Start evaluation cycle %d.' % cycle)
eval_results = evaluation(eval_estimator, config)
current_step = int(cycle * config.num_steps_per_eval)
evaluation.write_summary(eval_results, summary_writer,
current_step)
tf.logging.info('Starting training cycle %d.' % num_cycles)
train_estimator.train(input_fn=dataloader.InputReader(
config.training_file_pattern,
mode=tf.estimator.ModeKeys.TRAIN,
use_instance_mask=config.include_mask),
max_steps=config.total_steps)
eval_results = evaluation.evaluate(eval_estimator,
config.validation_file_pattern,
config.eval_samples,
config.eval_batch_size,
config.include_mask,
config.val_json_file)
evaluation.write_summary(eval_results, summary_writer,
config.total_steps)
summary_writer.close()
# Export saved model.
eval_estimator.export_saved_model(
export_dir_base=FLAGS.model_dir,
serving_input_receiver_fn=functools.partial(
serving_inputs.serving_input_fn,
batch_size=1,
desired_image_size=config.image_size,
padding_stride=(2**config.max_level),
input_type='image_bytes'))
else:
tf.logging.info('Mode not found.')
def main():
args = get_args()
torch.manual_seed(args.seed)
torch.cuda.manual_seed_all(args.seed)
if args.cuda and torch.cuda.is_available() and args.cuda_deterministic:
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True
log_dir = os.path.expanduser(args.log_dir)
eval_log_dir = log_dir + "_eval"
utils.cleanup_log_dir(log_dir)
utils.cleanup_log_dir(eval_log_dir)
torch.set_num_threads(1)
device = torch.device("cuda:" + str(args.cuda_id) if args.cuda else "cpu")
envs = make_vec_envs(args.env_name, args.seed, args.num_processes,
args.gamma, args.log_dir, device, False)
actor_critic = Policy(envs.observation_space.shape,
envs.action_space,
base_kwargs={'recurrent': args.recurrent_policy})
actor_critic.to(device)
if args.algo == 'a2c':
agent = algo.A2C_ACKTR(actor_critic,
args.value_loss_coef,
args.entropy_coef,
lr=args.lr,
eps=args.eps,
alpha=args.alpha,
max_grad_norm=args.max_grad_norm)
elif args.algo == 'ppo':
agent = algo.PPO(actor_critic,
args.clip_param,
args.ppo_epoch,
args.num_mini_batch,
args.value_loss_coef,
args.entropy_coef,
lr=args.lr,
eps=args.eps,
max_grad_norm=args.max_grad_norm)
elif args.algo == 'acktr':
agent = algo.A2C_ACKTR(actor_critic,
args.value_loss_coef,
args.entropy_coef,
acktr=True)
if args.gail:
assert len(envs.observation_space.shape) == 1
discr = gail.Discriminator(
envs.observation_space.shape[0] + envs.action_space.shape[0], 100,
device)
file_name = os.path.join(
args.gail_experts_dir,
"trajs_{}.pt".format(args.env_name.split('-')[0].lower()))
expert_dataset = gail.ExpertDataset(file_name,
num_trajectories=4,
subsample_frequency=20)
drop_last = len(expert_dataset) > args.gail_batch_size
gail_train_loader = torch.utils.data.DataLoader(
dataset=expert_dataset,
batch_size=args.gail_batch_size,
shuffle=True,
drop_last=drop_last)
########## file related
filename = args.env_name + "_" + args.algo + "_n" + str(args.max_episodes)
if args.attack:
filename += "_" + args.type + "_" + args.aim
filename += "_s" + str(args.stepsize) + "_m" + str(
args.maxiter) + "_r" + str(args.radius) + "_f" + str(args.frac)
if args.run >= 0:
filename += "_run" + str(args.run)
logger = get_log(args.logdir + filename + "_" + current_time)
logger.info(args)
rew_file = open(args.resdir + filename + ".txt", "w")
if args.compute:
radius_file = open(
args.resdir + filename + "_radius" + "_s" + str(args.stepsize) +
"_m" + str(args.maxiter) + "_th" + str(args.dist_thres) + ".txt",
"w")
if args.type == "targ" or args.type == "fgsm":
targ_file = open(args.resdir + filename + "_targ.txt", "w")
num_updates = int(
args.num_env_steps) // args.num_steps // args.num_processes
if args.type == "wb":
attack_net = WbAttacker(agent,
envs,
int(args.frac * num_updates),
num_updates,
args,
device=device)
if args.type == "bb":
attack_net = BbAttacker(agent,
envs,
int(args.frac * num_updates),
num_updates,
args,
device=device)
elif args.type == "rand":
attack_net = RandAttacker(envs,
radius=args.radius,
frac=args.frac,
maxat=int(args.frac * num_updates),
device=device)
elif args.type == "semirand":
attack_net = WbAttacker(agent,
envs,
int(args.frac * num_updates),
num_updates,
args,
device,
rand_select=True)
elif args.type == "targ":
if isinstance(envs.action_space, Discrete):
action_dim = envs.action_space.n
target_policy = action_dim - 1
elif isinstance(envs.action_space, Box):
action_dim = envs.action_space.shape[0]
target_policy = torch.zeros(action_dim)
# target_policy[-1] = 1
print("target policy is", target_policy)
attack_net = TargAttacker(agent,
envs,
int(args.frac * num_updates),
num_updates,
target_policy,
args,
device=device)
elif args.type == "fgsm":
if isinstance(envs.action_space, Discrete):
action_dim = envs.action_space.n
target_policy = action_dim - 1
elif isinstance(envs.action_space, Box):
action_dim = envs.action_space.shape[0]
target_policy = torch.zeros(action_dim)
def targ_policy(obs):
return target_policy
attack_net = FGSMAttacker(envs,
agent,
targ_policy,
radius=args.radius,
frac=args.frac,
maxat=int(args.frac * num_updates),
device=device)
# if args.aim == "obs" or aim == "hybrid":
# obs_space = gym.make(args.env_name).observation_space
# attack_net.set_obs_range(obs_space.low, obs_space.high)
rollouts = RolloutStorage(args.num_steps, args.num_processes,
envs.observation_space.shape, envs.action_space,
actor_critic.recurrent_hidden_state_size)
obs = envs.reset()
rollouts.obs[0].copy_(obs)
rollouts.to(device)
episode_rewards = deque(maxlen=10)
episode = 0
start = time.time()
for j in range(num_updates):
if args.use_linear_lr_decay:
# decrease learning rate linearly
utils.update_linear_schedule(
agent.optimizer, j, num_updates,
agent.optimizer.lr if args.algo == "acktr" else args.lr)
for step in range(args.num_steps):
# Sample actions
if args.type == "fgsm":
# print("before", rollouts.obs[step])
rollouts.obs[step] = attack_net.attack(
rollouts.obs[step], rollouts.recurrent_hidden_states[step],
rollouts.masks[step]).clone()
# print("after", rollouts.obs[step])
with torch.no_grad():
value, action, action_log_prob, recurrent_hidden_states = actor_critic.act(
rollouts.obs[step], rollouts.recurrent_hidden_states[step],
rollouts.masks[step])
if args.type == "targ" or args.type == "fgsm":
if isinstance(envs.action_space, Discrete):
num_target = (
action == target_policy).nonzero()[:, 0].size()[0]
targ_file.write(
str(num_target / args.num_processes) + "\n")
print("percentage of target:",
num_target / args.num_processes)
elif isinstance(envs.action_space, Box):
target_action = target_policy.repeat(action.size()[0], 1)
targ_file.write(
str(
torch.norm(action - target_action).item() /
args.num_processes) + "\n")
print("percentage of target:",
torch.sum(action).item() / args.num_processes)
# Obser reward and next obs
obs, reward, done, infos = envs.step(action.cpu())
for info in infos:
if 'episode' in info.keys():
episode_rewards.append(info['episode']['r'])
# rew_file.write("episode: {}, total reward: {}\n".format(episode, info['episode']['r']))
episode += 1
# If done then clean the history of observations.
masks = torch.FloatTensor([[0.0] if done_ else [1.0]
for done_ in done])
bad_masks = torch.FloatTensor(
[[0.0] if 'bad_transition' in info.keys() else [1.0]
for info in infos])
rollouts.insert(obs, recurrent_hidden_states, action,
action_log_prob, value, reward, masks, bad_masks)
with torch.no_grad():
next_value = actor_critic.get_value(
rollouts.obs[-1], rollouts.recurrent_hidden_states[-1],
rollouts.masks[-1]).detach()
if args.gail:
if j >= 10:
envs.venv.eval()
gail_epoch = args.gail_epoch
if j < 10:
gail_epoch = 100 # Warm up
for _ in range(gail_epoch):
discr.update(gail_train_loader, rollouts,
utils.get_vec_normalize(envs)._obfilt)
for step in range(args.num_steps):
rollouts.rewards[step] = discr.predict_reward(
rollouts.obs[step], rollouts.actions[step], args.gamma,
rollouts.masks[step])
if args.attack and args.type != "fgsm":
if args.aim == "reward":
logger.info(rollouts.rewards.flatten())
rollouts.rewards = attack_net.attack_r_general(
rollouts, next_value).clone().detach()
logger.info("after attack")
logger.info(rollouts.rewards.flatten())
elif args.aim == "obs":
origin = rollouts.obs.clone()
rollouts.obs = attack_net.attack_s_general(
rollouts, next_value).clone().detach()
logger.info(origin)
logger.info("after")
logger.info(rollouts.obs)
elif args.aim == "action":
origin = torch.flatten(rollouts.actions).clone()
rollouts.actions = attack_net.attack_a_general(
rollouts, next_value).clone().detach()
logger.info("attack value")
logger.info(torch.flatten(rollouts.actions) - origin)
elif args.aim == "hybrid":
res_aim, attack = attack_net.attack_hybrid(
rollouts, next_value, args.radius_s, args.radius_a,
args.radius_r)
print("attack ", res_aim)
if res_aim == "obs":
origin = rollouts.obs.clone()
rollouts.obs = attack.clone().detach()
logger.info(origin)
logger.info("attack obs")
logger.info(rollouts.obs)
elif res_aim == "action":
origin = torch.flatten(rollouts.actions).clone()
rollouts.actions = attack.clone().detach()
logger.info("attack action")
logger.info(torch.flatten(rollouts.actions) - origin)
elif res_aim == "reward":
logger.info(rollouts.rewards.flatten())
rollouts.rewards = attack.clone().detach()
logger.info("attack reward")
logger.info(rollouts.rewards.flatten())
if args.compute:
stable_radius = attack_net.compute_radius(rollouts, next_value)
print("stable radius:", stable_radius)
radius_file.write("update: {}, radius: {}\n".format(
j, np.round(stable_radius, decimals=3)))
rollouts.compute_returns(next_value, args.use_gae, args.gamma,
args.gae_lambda, args.use_proper_time_limits)
if args.attack and args.type == "bb":
attack_net.learning(rollouts)
value_loss, action_loss, dist_entropy = agent.update(rollouts)
rollouts.after_update()
# save for every interval-th episode or for the last epoch
if (j % args.save_interval == 0
or j == num_updates - 1) and args.save_dir != "":
save_path = os.path.join(args.save_dir, args.algo)
try:
os.makedirs(save_path)
except OSError:
pass
torch.save([
actor_critic,
getattr(utils.get_vec_normalize(envs), 'ob_rms', None)
], os.path.join(save_path, args.env_name + ".pt"))
if j % args.log_interval == 0 and len(episode_rewards) >= 1:
total_num_steps = (j + 1) * args.num_processes * args.num_steps
end = time.time()
print(
"Updates {}, num timesteps {}, FPS {} \n Last {} training episodes: mean/median reward {:.1f}/{:.1f}, min/max reward {:.1f}/{:.1f}\n"
.format(j, total_num_steps,
int(total_num_steps / (end - start)),
len(episode_rewards), np.mean(episode_rewards),
np.median(episode_rewards), np.min(episode_rewards),
np.max(episode_rewards), dist_entropy, value_loss,
action_loss))
rew_file.write("updates: {}, mean reward: {}\n".format(
j, np.mean(episode_rewards)))
if (args.eval_interval is not None and len(episode_rewards) > 1
and j % args.eval_interval == 0):
ob_rms = utils.get_vec_normalize(envs).ob_rms
evaluate(actor_critic, ob_rms, args.env_name, args.seed,
args.num_processes, eval_log_dir, device)
# if episode > args.max_episodes:
# print("reach episodes limit")
# break
if args.attack:
logger.info("total attacks: {}\n".format(attack_net.attack_num))
print("total attacks: {}\n".format(attack_net.attack_num))
rew_file.close()
if args.compute:
radius_file.close()
if args.type == "targ" or args.type == "fgsm":
targ_file.close()
import moves
import evaluation
import sys # import necessary libraries
import pygame
pygame.init() # initialize pygame
while True: # starts game loop
for event in pygame.event.get(): # interrupt request
if event.type == pygame.QUIT:
sys.exit()
if constants.RUNNING == False: # game is finished
evaluation.evaluate() # evaluate match
basic_functions.reset_game() # restart game
if constants.RUNNING == True: # game is running
basic_functions.draw_window() # update pygame window
if constants.GAMEMODE == 0: # human vs human
moves.human_move() # execute human move
elif constants.GAMEMODE == 1: # AI vs human
moves.ai_move() # if AIs turn execute AI move
moves.human_move() # if not execute human move
elif constants.GAMEMODE == 2: # AI vs AI
moves.ai_move() # execute AI move
def train(args):
"""Maximum Likelihood Estimation"""
# load in train/dev set
train_set = Dataset.from_bin_file(args.train_file)
if args.dev_file:
dev_set = Dataset.from_bin_file(args.dev_file)
else:
dev_set = Dataset(examples=[])
vocab = pickle.load(open(args.vocab, 'rb'))
grammar = ASDLGrammar.from_text(open(args.asdl_file).read())
transition_system = Registrable.by_name(args.transition_system)(grammar)
parser_cls = Registrable.by_name(args.parser) # TODO: add arg
if args.pretrain:
print('Finetune with: ', args.pretrain, file=sys.stderr)
model = parser_cls.load(model_path=args.pretrain, cuda=args.cuda)
else:
model = parser_cls(args, vocab, transition_system)
model.train()
evaluator = Registrable.by_name(args.evaluator)(transition_system,
args=args)
if args.cuda: model.cuda()
optimizer_cls = eval('torch.optim.%s' %
args.optimizer) # FIXME: this is evil!
optimizer = optimizer_cls(model.parameters(), lr=args.lr)
if not args.pretrain:
if args.uniform_init:
print('uniformly initialize parameters [-%f, +%f]' %
(args.uniform_init, args.uniform_init),
file=sys.stderr)
nn_utils.uniform_init(-args.uniform_init, args.uniform_init,
model.parameters())
elif args.glorot_init:
print('use glorot initialization', file=sys.stderr)
nn_utils.glorot_init(model.parameters())
# load pre-trained word embedding (optional)
if args.glove_embed_path:
print('load glove embedding from: %s' % args.glove_embed_path,
file=sys.stderr)
glove_embedding = GloveHelper(args.glove_embed_path)
glove_embedding.load_to(model.src_embed, vocab.source)
print('begin training, %d training examples, %d dev examples' %
(len(train_set), len(dev_set)),
file=sys.stderr)
print('vocab: %s' % repr(vocab), file=sys.stderr)
epoch = train_iter = 0
report_loss = report_examples = report_sup_att_loss = 0.
history_dev_scores = []
num_trial = patience = 0
while True:
epoch += 1
epoch_begin = time.time()
for batch_examples in train_set.batch_iter(batch_size=args.batch_size,
shuffle=True):
batch_examples = [
e for e in batch_examples
if len(e.tgt_actions) <= args.decode_max_time_step
]
train_iter += 1
optimizer.zero_grad()
ret_val = model.score(batch_examples)
loss = -ret_val[0]
# print(loss.data)
loss_val = torch.sum(loss).data.item()
report_loss += loss_val
report_examples += len(batch_examples)
loss = torch.mean(loss)
if args.sup_attention:
att_probs = ret_val[1]
if att_probs:
sup_att_loss = -torch.log(torch.cat(att_probs)).mean()
sup_att_loss_val = sup_att_loss.data[0]
report_sup_att_loss += sup_att_loss_val
loss += sup_att_loss
loss.backward()
# clip gradient
if args.clip_grad > 0.:
grad_norm = torch.nn.utils.clip_grad_norm_(
model.parameters(), args.clip_grad)
optimizer.step()
if train_iter % args.log_every == 0:
log_str = '[Iter %d] encoder loss=%.5f' % (
train_iter, report_loss / report_examples)
if args.sup_attention:
log_str += ' supervised attention loss=%.5f' % (
report_sup_att_loss / report_examples)
report_sup_att_loss = 0.
print(log_str, file=sys.stderr)
report_loss = report_examples = 0.
print('[Epoch %d] epoch elapsed %ds' %
(epoch, time.time() - epoch_begin),
file=sys.stderr)
if args.save_all_models:
model_file = args.save_to + '.iter%d.bin' % train_iter
print('save model to [%s]' % model_file, file=sys.stderr)
model.save(model_file)
# perform validation
is_better = False
if args.dev_file:
if epoch % args.valid_every_epoch == 0:
print('[Epoch %d] begin validation' % epoch, file=sys.stderr)
eval_start = time.time()
eval_results = evaluation.evaluate(
dev_set.examples,
model,
evaluator,
args,
verbose=False,
eval_top_pred_only=args.eval_top_pred_only)
dev_score = eval_results[evaluator.default_metric]
print(
'[Epoch %d] evaluate details: %s, dev %s: %.5f (took %ds)'
% (epoch, eval_results, evaluator.default_metric,
dev_score, time.time() - eval_start),
file=sys.stderr)
is_better = history_dev_scores == [] or dev_score > max(
history_dev_scores)
history_dev_scores.append(dev_score)
else:
is_better = True
if args.decay_lr_every_epoch and epoch > args.lr_decay_after_epoch:
lr = optimizer.param_groups[0]['lr'] * args.lr_decay
print('decay learning rate to %f' % lr, file=sys.stderr)
# set new lr
for param_group in optimizer.param_groups:
param_group['lr'] = lr
if is_better:
patience = 0
model_file = args.save_to + '.bin'
print('save the current model ..', file=sys.stderr)
print('save model to [%s]' % model_file, file=sys.stderr)
model.save(model_file)
# also save the optimizers' state
torch.save(optimizer.state_dict(), args.save_to + '.optim.bin')
elif patience < args.patience and epoch >= args.lr_decay_after_epoch:
patience += 1
print('hit patience %d' % patience, file=sys.stderr)
if epoch == args.max_epoch:
print('reached max epoch, stop!', file=sys.stderr)
exit(0)
if patience >= args.patience and epoch >= args.lr_decay_after_epoch:
num_trial += 1
print('hit #%d trial' % num_trial, file=sys.stderr)
if num_trial == args.max_num_trial:
print('early stop!', file=sys.stderr)
exit(0)
# decay lr, and restore from previously best checkpoint
lr = optimizer.param_groups[0]['lr'] * args.lr_decay
print('load previously best model and decay learning rate to %f' %
lr,
file=sys.stderr)
# load model
params = torch.load(args.save_to + '.bin',
map_location=lambda storage, loc: storage)
model.load_state_dict(params['state_dict'])
if args.cuda: model = model.cuda()
# load optimizers
if args.reset_optimizer:
print('reset optimizer', file=sys.stderr)
optimizer = torch.optim.Adam(model.parameters(), lr=lr)
else:
print('restore parameters of the optimizers', file=sys.stderr)
optimizer.load_state_dict(
torch.load(args.save_to + '.optim.bin'))
# set new lr
for param_group in optimizer.param_groups:
param_group['lr'] = lr
# reset patience
patience = 0
def test_semi_training(test_session):
rv = predict(date(2012, 7, 16))
report_data = evaluate(rv)
print(report_static_test(report_data, flag='Semi'))
if features == 'w2v' or features == 'w2v_and_phrases' or features == 'w2v_and_posneg':
mdl.fit(datafeatures['train'], reviewgts['train'])
del datafeatures['train']
elif features == 'phrases':
mdl.fit(phrasefeatures['train'], reviewgts['train'])
del phrasefeatures['train']
elif features == 'posneg':
mdl.fit(posnegfeatures['train'], reviewgts['train'])
del posnegfeatures['train']
elif features == 'unigrams':
mdl.fit(X_train, reviewgts['train'])
del X_train
id_preds = {}
id_gts = {}
if features == 'w2v' or features == 'w2v_and_phrases' or features == 'w2v_and_posneg':
y_pred = mdl.predict(datafeatures['test'])
elif features == 'phrases':
y_pred = mdl.predict(phrasefeatures['test'])
elif features == 'posneg':
y_pred = mdl.predict(posnegfeatures['test'])
elif features == 'unigrams':
y_pred = mdl.predict(X_test)
for k, reviewid in enumerate(reviewids['test']):
id_preds[reviewid] = y_pred[k]
id_gts[reviewid] = reviewgts['test'][k]
evaluation.evaluate(id_preds, id_gts, outfile)
# deserialization of classifier object
classifier_file = open("classifier_data",'rb')
classifier = pickle.load(classifier_file)
classifier_file.close()
# deserialization of parametrizer object
parametrizer_file = open("parametrizer_data",'rb')
parametrizer = pickle.load(parametrizer_file)
parametrizer_file.close()
# testing
test_manager = ConfigurationManager(join(getcwd(),"test"))
test_filenames = test_manager.training_data(0)
for filename in test_manager.test_data(0):
test_filenames.append(filename)
test_data = get_samples_matrix(test_filenames, parametrizer)
prediction = classifier.predict(test_data)
#Writing to csv file
with open('results.csv', 'w',newline='') as csvfile:
result_writer=csv.writer(csvfile, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL)
for i,file in enumerate(test_filenames):
file=file[(len(file)-7):]
probability=max(prediction[i])
answer = where(prediction[i,:]==probability)[0][0]
result_writer.writerow([file] + [answer] + [probability])
evaluate()
e2_mask=marked_e2,
attention_mask=masks_tensors,
input_relation_emb=relation_emb,
labels=labels)
loss = outputs[0]
loss.backward()
optimizer.step()
running_loss += loss.item()
if step % 1000 == 0:
print(f'[step {step}]' + '=' * (step // 1000))
print('============== EVALUATION ON DEV DATA ==============')
preds = extract_relation_emb(model, devloader).cpu().numpy()
p, r, f1 = evaluate(preds, val_y_attr, val_y, val_idxmap,
len(set(train_label)), args.dist_func)
print(
f'loss: {running_loss:.2f}, precision: {p:.4f}, recall: {r:.4f}, f1 score: {f1:.4f}'
)
print('============== EVALUATION ON TEST DATA ==============')
preds = extract_relation_emb(model, testloader).cpu().numpy()
pt, rt, f1t = evaluate(preds, test_y_attr, test_y, test_idxmap,
len(set(train_label)) + len(set(dev_label)),
args.dist_func)
print(
f'[testing performance] precision: {pt:.4f}, recall: {rt:.4f}, f1 score: {f1t:.4f}'
)
if f1 > best_f1:
best_p = p
counter += 1
return reviewFeatureVecs
os.system('cls')
# Load Word2Vec model here
print("LOADING WORD2VEC MODEL \n\n")
FILE = "W2V Models/w2v_reddit_unigram_300d.bin"
model = w2v.load_word2vec_format(FILE, binary=True)
# Load the dataset here
print("LOADING DATASET \n\n")
df = pd.read_csv('clean_dataset.csv')
# Separate out comments and labels
X , y = df['Comment'], df['Insult']
# Transform the data
print("TRANSFORMING DATA \n\n")
X = getAvgFeatureVecs(X, model, 300)
# Get the Python's file name. Remove the .py extension
file_name = os.path.basename(__file__)
file_name = file_name.replace(".py","")
# Evaluate models
print("EVALUATING \n\n")
evaluate(X,y, file_name)
def main():
args = get_args()
# CUDA setting
if not torch.cuda.is_available():
raise ValueError("Should buy GPU!")
torch.manual_seed(args.seed)
torch.cuda.manual_seed_all(args.seed)
device = torch.device('cuda')
torch.set_default_tensor_type('torch.cuda.FloatTensor')
torch.backends.cudnn.benchmark = True
def _rescale(img):
return img * 2.0 - 1.0
def _noise_adder(img):
return torch.empty_like(img, dtype=img.dtype).uniform_(0.0, 1/128.0) + img
minority_class_labels = [0,1,2,3,4]
train_transform = transforms.Compose([
transforms.Resize(64),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
train_dataset = cifar10.CIFAR10(root='./data',
train=True,
download=True,
transform=train_transform,
minority_classes = minority_class_labels,
keep_ratio = 0.05)
if args.oversample == 1:
oversampler = createOverSampler(train_dataset)
train_loader = cycle(torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size,
shuffle = False, num_workers=args.num_workers,sampler=oversampler))
else:
train_loader = iter(torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size,
sampler=InfiniteSamplerWrapper(train_dataset),
num_workers=args.num_workers,
pin_memory=True))
if args.calc_FID:
# eval_dataset = datasets.ImageFolder(
# os.path.join(args.data_root, 'val'),
# transforms.Compose([
# transforms.ToTensor(), _rescale,
# ])
# )
# eval_loader = iter(data.DataLoader(
# eval_dataset, args.batch_size,
# sampler=InfiniteSamplerWrapper(eval_dataset),
# num_workers=args.num_workers, pin_memory=True)
# )
eval_dataset = cifar10.CIFAR10(root=args.data_root,
train=False,
download=True,
transform=train_transform,
minority_classes = None,
keep_ratio = None)
eval_loader = iter(torch.utils.data.DataLoader(eval_dataset, batch_size=args.batch_size,
sampler=InfiniteSamplerWrapper(eval_dataset),
num_workers=args.num_workers,
pin_memory=True))
# eval_loader = cycle(torch.utils.data.DataLoader(eval_dataset, batch_size=args.batch_size,
# shuffle = False,
# num_workers=args.num_workers))
else:
eval_loader = None
num_classes = len(train_dataset.classes)
print(' prepared datasets...')
print(' Number of training images: {}'.format(len(train_dataset)))
# Prepare directories.
args.num_classes = num_classes
args, writer = prepare_results_dir(args)
# initialize models.
_n_cls = num_classes if args.cGAN else 0
gen = ResNetGenerator(
args.gen_num_features, args.gen_dim_z, args.gen_bottom_width,
activation=F.relu, num_classes=_n_cls, distribution=args.gen_distribution
).to(device)
if args.dis_arch_concat:
dis = SNResNetConcatDiscriminator(args.dis_num_features, _n_cls, F.relu, args.dis_emb).to(device)
else:
dis = SNResNetProjectionDiscriminator(args.dis_num_features, _n_cls, F.relu, args.transform_space).to(device)
inception_model = inception.InceptionV3().to(device) if args.calc_FID else None
inception_model = torch.nn.DataParallel(inception_model)
gen = torch.nn.DataParallel(gen)
dis = torch.nn.DataParallel(dis)
opt_gen = optim.Adam(gen.parameters(), args.lr, (args.beta1, args.beta2))
opt_dis = optim.Adam(dis.parameters(), args.lr, (args.beta1, args.beta2))
# gen_criterion = getattr(L, 'gen_{}'.format(args.loss_type))
# dis_criterion = getattr(L, 'dis_{}'.format(args.loss_type))
gen_criterion = L.GenLoss(args.loss_type, args.relativistic_loss)
dis_criterion = L.DisLoss(args.loss_type, args.relativistic_loss)
print(' Initialized models...\n')
if args.args_path is not None:
print(' Load weights...\n')
prev_args, gen, opt_gen, dis, opt_dis = utils.resume_from_args(
args.args_path, args.gen_ckpt_path, args.dis_ckpt_path
)
# Training loop
for n_iter in tqdm.tqdm(range(1, args.max_iteration + 1)):
if n_iter >= args.lr_decay_start:
decay_lr(opt_gen, args.max_iteration, args.lr_decay_start, args.lr)
decay_lr(opt_dis, args.max_iteration, args.lr_decay_start, args.lr)
# ==================== Beginning of 1 iteration. ====================
_l_g = .0
cumulative_loss_dis = .0
for i in range(args.n_dis):
if i == 0:
fake, pseudo_y, _ = sample_from_gen(args, device, num_classes, gen)
dis_fake = dis(fake, pseudo_y)
if args.relativistic_loss:
real, y = sample_from_data(args, device, train_loader)
dis_real = dis(real, y)
else:
dis_real = None
loss_gen = gen_criterion(dis_fake, dis_real)
gen.zero_grad()
loss_gen.backward()
opt_gen.step()
_l_g += loss_gen.item()
if n_iter % 10 == 0 and writer is not None:
writer.add_scalar('gen', _l_g, n_iter)
fake, pseudo_y, _ = sample_from_gen(args, device, num_classes, gen)
real, y = sample_from_data(args, device, train_loader)
dis_fake, dis_real = dis(fake, pseudo_y), dis(real, y)
loss_dis = dis_criterion(dis_fake, dis_real)
# for k,v in dis.named_parameters():
# if "transformer.layers.1.linear1.bias" in k:
# embedding_weights_a = v.clone()
# if "block5.c2.bias" in k:
# embedding_weights_a = v.clone()
# print (embedding_weights_a)
dis.zero_grad()
loss_dis.backward()
opt_dis.step()
#
# for k,v in dis.named_parameters():
# if "transformer.layers.1.linear1.bias" in k:
# embedding_weights_b = v.clone()
#
# # if "block5.c2.bias" in k:
# # embedding_weights_b = v.clone()
#
# print (torch.equal(embedding_weights_a.data, embedding_weights_b.data))
cumulative_loss_dis += loss_dis.item()
if n_iter % 10 == 0 and i == args.n_dis - 1 and writer is not None:
cumulative_loss_dis /= args.n_dis
writer.add_scalar('dis', cumulative_loss_dis / args.n_dis, n_iter)
# ==================== End of 1 iteration. ====================
if n_iter % args.log_interval == 0:
tqdm.tqdm.write(
'iteration: {:07d}/{:07d}, loss gen: {:05f}, loss dis {:05f}'.format(
n_iter, args.max_iteration, _l_g, cumulative_loss_dis))
if not args.no_image:
writer.add_image(
'fake', torchvision.utils.make_grid(
fake, nrow=4, normalize=True, scale_each=True))
writer.add_image(
'real', torchvision.utils.make_grid(
real, nrow=4, normalize=True, scale_each=True))
# Save previews
utils.save_images(
n_iter, n_iter // args.checkpoint_interval, args.results_root,
args.train_image_root, fake[:32], real[:32]
)
if n_iter % args.checkpoint_interval == 0:
# Save checkpoints!
utils.save_checkpoints(
args, n_iter, n_iter // args.checkpoint_interval,
gen, opt_gen, dis, opt_dis
)
if n_iter % args.eval_interval == 0:
# TODO (crcrpar): implement Ineption score, FID, and Geometry score
# Once these criterion are prepared, val_loader will be used.
fid_score = evaluation.evaluate(
args, n_iter, gen, device, inception_model, eval_loader, to_save = True
)
tqdm.tqdm.write(
'[Eval] iteration: {:07d}/{:07d}, FID: {:07f}'.format(
n_iter, args.max_iteration, fid_score))
if writer is not None:
writer.add_scalar("FID", fid_score, n_iter)
# Project embedding weights if exists.
embedding_layer = getattr(dis, 'l_y', None)
if embedding_layer is not None:
writer.add_embedding(
embedding_layer.weight.data,
list(range(args.num_classes)),
global_step=n_iter
)
if args.test:
shutil.rmtree(args.results_root)
print "Mean V metric:", np.mean(vmetric)
if WORKING_DATASET != "test2014":
print "P10,CR10,F10,P20,CR20,F20"
evaluate(
OUTFILE,
WORKING_DATASET,
EVAL_CSV,
[
METHOD,
WORKING_DATASET,
USE_FILTER,
SUPERVISED,
SUPERVISED_DATASETS,
VISUAL_DESCRIPTORS,
OTHER_DESCRIPTORS,
SIM_METRIC,
USE_CREDIBILITY,
APPLY_NEW_RANK_FILE,
AUXILIAR_METHOD,
MULTIGRAPH_MIN_THRESHOLD,
MULTIGRAPH_MEAN_THRESHOLD,
MULTIGRAPH_MAX_THRESHOLD,
MULTIGRAPH_MIN_INCREMENT,
MULTIGRAPH_MEAN_INCREMENT,
MULTIGRAPH_MAX_INCREMENT,
],
)
"""
if WORKING_DATASET == "test2013":
if poi == "Castle Estense Ferrara":
model = LSTM(units=50, return_sequences=True, recurrent_dropout=0.1)(model)
out = TimeDistributed(Dense(n_tags, activation="softmax"))(model)
model = Model(input, out)
model.compile(optimizer="rmsprop",
loss="categorical_crossentropy",
metrics=['accuracy'])
print(model.summary())
model.fit(X_word_tr,
np.array(y_tr),
batch_size=10,
epochs=n_epoch,
validation_split=0.1,
verbose=1)
#======================
#Eval
#======================
result = evaluation.evaluate(X_word_te, y_te, model, data, X_word_te)
Acc += result['Accuracy']
prec += result['precision']
recall += result['Recall']
f1 += result['f1_score']
print('Accuracy', Acc / n_splits)
print('Recall', recall / n_splits)
print('precision', prec / n_splits)
print('f1_score', f1 / n_splits)
def main():
args = get_args()
torch.manual_seed(args.seed)
torch.cuda.manual_seed_all(args.seed)
if args.cuda and torch.cuda.is_available() and args.cuda_deterministic:
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True
log_dir = os.path.expanduser(args.log_dir)
eval_log_dir = log_dir + "_eval"
utils.cleanup_log_dir(log_dir)
utils.cleanup_log_dir(eval_log_dir)
torch.set_num_threads(1)
device = torch.device("cuda:0" if args.cuda else "cpu")
# coinrun environments need to be treated differently.
coinrun_envs = {
'CoinRun': 'standard',
'CoinRun-Platforms': 'platform',
'Random-Mazes': 'maze'
}
envs = make_vec_envs(args.env_name,
args.seed,
args.num_processes,
args.gamma,
args.log_dir,
device,
False,
coin_run_level=args.num_levels,
difficulty=args.high_difficulty,
coin_run_seed=args.seed)
if args.env_name in coinrun_envs.keys():
observation_space_shape = (3, 64, 64)
args.save_dir = args.save_dir + "/NUM_LEVELS_{}".format(
args.num_levels) # Save the level info in the
else:
observation_space_shape = envs.observation_space.shape
# trained model name
if args.continue_ppo_training:
actor_critic, _ = torch.load(os.path.join(args.check_point,
args.env_name + ".pt"),
map_location=torch.device(device))
elif args.cor_gail:
embed_size = args.embed_size
actor_critic = Policy(observation_space_shape,
envs.action_space,
hidden_size=args.hidden_size,
embed_size=embed_size,
base_kwargs={'recurrent': args.recurrent_policy})
actor_critic.to(device)
correlator = Correlator(observation_space_shape,
envs.action_space,
hidden_dim=args.hidden_size,
embed_dim=embed_size,
lr=args.lr,
device=device)
correlator.to(device)
embeds = torch.zeros(1, embed_size)
else:
embed_size = 0
actor_critic = Policy(observation_space_shape,
envs.action_space,
hidden_size=args.hidden_size,
base_kwargs={'recurrent': args.recurrent_policy})
actor_critic.to(device)
embeds = None
if args.algo == 'a2c':
agent = algo.A2C_ACKTR(actor_critic,
args.value_loss_coef,
args.entropy_coef,
lr=args.lr,
eps=args.eps,
alpha=args.alpha,
max_grad_norm=args.max_grad_norm)
elif args.algo == 'ppo':
agent = algo.PPO(actor_critic,
args.clip_param,
args.ppo_epoch,
args.num_mini_batch,
args.value_loss_coef,
args.entropy_coef,
lr=args.lr,
eps=args.eps,
max_grad_norm=args.max_grad_norm,
use_clipped_value_loss=True,
ftrl_mode=args.cor_gail or args.no_regret_gail,
correlated_mode=args.cor_gail)
elif args.algo == 'acktr':
agent = algo.A2C_ACKTR(actor_critic,
args.value_loss_coef,
args.entropy_coef,
acktr=True)
if args.gail or args.no_regret_gail or args.cor_gail:
file_name = os.path.join(
args.gail_experts_dir,
"trajs_{}.pt".format(args.env_name.split('-')[0].lower()))
expert_dataset = gail.ExpertDataset(
file_name, num_trajectories=50,
subsample_frequency=1) #if subsample set to a different number,
# grad_pen might need adjustment
drop_last = len(expert_dataset) > args.gail_batch_size
gail_train_loader = torch.utils.data.DataLoader(
dataset=expert_dataset,
batch_size=args.gail_batch_size,
shuffle=True,
drop_last=drop_last)
if args.gail:
discr = gail.Discriminator(observation_space_shape,
envs.action_space,
device=device)
if args.no_regret_gail or args.cor_gail:
queue = deque(
maxlen=args.queue_size
) # Strategy Queues: Each element of a queue is a dicr strategy
agent_queue = deque(
maxlen=args.queue_size
) # Strategy Queues: Each element of a queue is an agent strategy
pruning_frequency = 1
if args.no_regret_gail:
discr = regret_gail.NoRegretDiscriminator(observation_space_shape,
envs.action_space,
device=device)
if args.cor_gail:
discr = cor_gail.CorDiscriminator(observation_space_shape,
envs.action_space,
hidden_size=args.hidden_size,
embed_size=embed_size,
device=device)
discr.to(device)
rollouts = RolloutStorage(args.num_steps, args.num_processes,
observation_space_shape, envs.action_space,
actor_critic.recurrent_hidden_state_size,
embed_size)
obs = envs.reset()
rollouts.obs[0].copy_(obs)
if args.cor_gail:
rollouts.embeds[0].copy_(embeds)
rollouts.to(device)
episode_rewards = deque(maxlen=10)
start = time.time()
num_updates = int(
args.num_env_steps) // args.num_steps // args.num_processes
for j in range(num_updates):
if args.use_linear_lr_decay:
# decrease learning rate linearly
utils.update_linear_schedule(
agent.optimizer, j, num_updates,
agent.optimizer.lr if args.algo == "acktr" else args.lr)
for step in range(args.num_steps):
# Sample actions # Roll-out
with torch.no_grad():
value, action, action_log_prob, recurrent_hidden_states = actor_critic.act(
rollouts.obs[step], rollouts.recurrent_hidden_states[step],
rollouts.masks[step], rollouts.embeds[step])
obs, reward, done, infos = envs.step(action.to('cpu'))
for info in infos:
if 'episode' in info.keys():
episode_rewards.append(info['episode']['r'])
# If done then clean the history of observations.
masks = torch.FloatTensor([[0.0] if done_ else [1.0]
for done_ in done])
bad_masks = torch.FloatTensor(
[[0.0] if 'bad_transition' in info.keys() else [1.0]
for info in infos])
rollouts.insert(obs, recurrent_hidden_states, action,
action_log_prob, value, reward, masks, bad_masks)
# Sample mediating/correlating actions # Correlated Roll-out
if args.cor_gail:
embeds, embeds_log_prob, mean = correlator.act(
rollouts.obs[step], rollouts.actions[step])
rollouts.insert_embedding(embeds, embeds_log_prob)
with torch.no_grad():
next_value = actor_critic.get_value(
rollouts.obs[-1], rollouts.recurrent_hidden_states[-1],
rollouts.masks[-1], rollouts.embeds[-1]).detach()
if args.gail or args.no_regret_gail or args.cor_gail:
if args.env_name not in {'CoinRun', 'Random-Mazes'}:
if j >= 10:
envs.venv.eval()
gail_epoch = args.gail_epoch
if args.gail:
if j < 10:
gail_epoch = 100 # Warm up
# no need for gail epoch or warm up in the no-regret case and cor_gail.
for _ in range(gail_epoch):
if utils.get_vec_normalize(envs):
obfilt = utils.get_vec_normalize(envs)._obfilt
else:
obfilt = None
if args.gail:
discr.update(gail_train_loader, rollouts, obfilt)
if args.no_regret_gail or args.cor_gail:
last_strategy = discr.update(gail_train_loader, rollouts,
queue, args.max_grad_norm,
obfilt, j)
for step in range(args.num_steps):
if args.gail:
rollouts.rewards[step] = discr.predict_reward(
rollouts.obs[step], rollouts.actions[step], args.gamma,
rollouts.masks[step])
if args.no_regret_gail:
rollouts.rewards[step] = discr.predict_reward(
rollouts.obs[step], rollouts.actions[step], args.gamma,
rollouts.masks[step], queue)
if args.cor_gail:
rollouts.rewards[
step], correlator_reward = discr.predict_reward(
rollouts.obs[step], rollouts.actions[step],
rollouts.embeds[step], args.gamma,
rollouts.masks[step], queue)
rollouts.correlated_reward[step] = correlator_reward
rollouts.compute_returns(next_value, args.use_gae, args.gamma,
args.gae_lambda, args.use_proper_time_limits)
if args.gail:
value_loss, action_loss, dist_entropy = agent.update(rollouts, j)
elif args.no_regret_gail or args.cor_gail:
value_loss, action_loss, dist_entropy, agent_gains, agent_strategy = \
agent.mixed_update(rollouts, agent_queue, j)
if args.cor_gail:
correlator.update(rollouts, agent_gains, args.max_grad_norm)
if args.no_regret_gail or args.cor_gail:
queue, _ = utils.queue_update(queue, pruning_frequency,
args.queue_size, j, last_strategy)
agent_queue, pruning_frequency = utils.queue_update(
agent_queue, pruning_frequency, args.queue_size, j,
agent_strategy)
rollouts.after_update()
# save for every interval-th episode or for the last epoch
if (j % args.save_interval == 0
or j == num_updates - 1) and args.save_dir != "":
save_path = os.path.join(args.save_dir, args.algo)
try:
os.makedirs(save_path)
except OSError:
pass
if not args.cor_gail:
torch.save([
actor_critic,
getattr(utils.get_vec_normalize(envs), 'ob_rms', None)
], os.path.join(save_path, args.env_name + ".pt"))
else:
print("saving models in {}".format(
os.path.join(save_path, args.env_name)))
torch.save(
correlator.state_dict(),
os.path.join(save_path, args.env_name + "correlator.pt"))
torch.save([
actor_critic.state_dict(),
getattr(utils.get_vec_normalize(envs), 'ob_rms', None)
], os.path.join(save_path, args.env_name + "actor.pt"))
if j % args.log_interval == 0 and len(episode_rewards) > 1:
total_num_steps = (j + 1) * args.num_processes * args.num_steps
end = time.time()
print(
"Updates {}, num timesteps {}, FPS {} \n Last {} training episodes: mean/median reward {:.1f}/{:.1f},"
" value loss/action loss {:.1f}/{}".format(
j, total_num_steps, int(total_num_steps / (end - start)),
len(episode_rewards), np.mean(episode_rewards),
np.median(episode_rewards), value_loss, action_loss))
if (args.eval_interval is not None and len(episode_rewards) > 1
and j % args.eval_interval == 0):
ob_rms = utils.get_vec_normalize(envs).ob_rms
evaluate(actor_critic, ob_rms, args.env_name, args.seed,
args.num_processes, eval_log_dir, device)
def test(args, data_generator, logging):
'''
Test split evaluation.
'''
logging.info('\n===> Evaluate test split fold {}'.format(args.fold))
if args.task_type == 'sed_only':
task_type = 'sed_only'
submissions_model = args.model_sed
logging.info('\n===> Test SED')
elif args.task_type == 'seld':
task_type = 'seld'
submissions_model = args.model_sed
logging.info('\n===> Test SELD')
elif args.task_type == 'doa_only':
task_type = 'doa_only'
submissions_model = args.model_doa
logging.info('\n===> Test DOA')
elif args.task_type == 'two_staged_eval':
task_type = 'doa_only'
submissions_model = args.model_sed
logging.info('\n===> Two Staged Eval')
# Inference
model_path = os.path.join(
models_dir, task_type,
args.name + '_' + args.model + '_{}'.format(args.audio_type) +
'_{}'.format(args.feature_type) + '_aug_{}'.format(args.data_aug) +
'_fold_{}'.format(args.fold) + '_seed_{}'.format(args.seed),
'epoch_{}.pth'.format(args.epoch_num))
assert os.path.exists(model_path), 'Error: no checkpoint file found!'
model = models.__dict__[args.model](class_num, args.model_pool_type,
args.model_pool_size, None)
checkpoint = torch.load(model_path,
map_location=lambda storage, loc: storage)
model.load_state_dict(checkpoint['model_state_dict'])
if args.cuda:
model.cuda()
fold_submissions_dir = os.path.join(
submissions_dir, args.name + '_' + submissions_model +
'_{}'.format(args.audio_type) + '_{}'.format(args.feature_type) +
'_aug_{}'.format(args.data_aug) + '_seed_{}'.format(args.seed),
'_test')
shutil.rmtree(fold_submissions_dir, ignore_errors=True)
os.makedirs(fold_submissions_dir, exist_ok=False)
test_metrics = evaluation.evaluate(data_generator=data_generator,
data_type='test',
max_audio_num=None,
task_type=args.task_type,
model=model,
cuda=args.cuda,
loss_type=loss_type,
threshold=threshold,
submissions_dir=fold_submissions_dir,
frames_per_1s=frames_per_1s,
sub_frames_per_1s=sub_frames_per_1s,
FUSION=args.fusion,
epoch_num=args.epoch_num)
logging.info(
'------------------------------------------------------------------------------------------------------------------------------------'
)
logging_and_writer('test', test_metrics, logging)
logging.info(
'------------------------------------------------------------------------------------------------------------------------------------'
)
if args.task_type == 'sed_only':
test_submissions_dir = os.path.join(
submissions_dir, args.name + '_' + args.model_sed +
'_{}'.format(args.audio_type) + '_{}'.format(args.feature_type) +
'_aug_{}'.format(args.data_aug) + '_seed_{}'.format(args.seed),
'sed_test')
elif args.task_type == 'two_staged_eval':
test_submissions_dir = os.path.join(
submissions_dir, args.name + '_' + args.model_sed +
'_{}'.format(args.audio_type) + '_{}'.format(args.feature_type) +
'_aug_{}'.format(args.data_aug) + '_seed_{}'.format(args.seed),
'all_test')
os.makedirs(test_submissions_dir, exist_ok=True)
for fn in sorted(os.listdir(fold_submissions_dir)):
if fn.endswith('.csv') and not fn.startswith('.'):
src = os.path.join(fold_submissions_dir, fn)
dst = os.path.join(test_submissions_dir, fn)
shutil.copyfile(src, dst)
table = tb.construct_race_table(Qs, Qr, race_set, t_way)
if t_way > 1:
table = tb.expand_table(Qr, Qs, race_set, table, t_way)
elapsed_time = time.time() - start
print("\nCreating race table took:{:.4g}".format(elapsed_time) +
"[sec]")
table = table.astype('int64')
check_digit = 1
start = time.time()
results = test.create_new_testcase(number, check_digit, Qr, Qs, table,
race_set, Qr_unique, Qs_unique)
Qr = results['recv']
Qs = results['send']
elapsed_time = time.time() - start
print("Creating test case took:{:.4g}".format(elapsed_time) + "[sec]")
print('The number of Test Case is {}.'.format(len(table)))
evaluation = ev.evaluate(Qr, Qs)
Q = pd.concat([Qs[0], Qr[0]]).sort_index()
if way == 0:
pre_results = pre_results.append(evaluation, ignore_index=True)
elif way == 1:
new_results = new_results.append(evaluation, ignore_index=True)
else:
print('error')
_os_.save_file(RESULTS_FILE_NAME, results_path, pre_results, new_results)
def train(args, data_generator, model, optimizer, initial_epoch, logging):
'''
Train goes here
'''
# set up tensorboard writer
current_time = datetime.now().strftime('%b%d_%H-%M-%S')
tb_dir = os.path.join(
'runs',
datetime.now().strftime('%b%d'), args.task_type,
args.name + '_' + args.model + '_{}'.format(args.audio_type) +
'_{}'.format(args.feature_type) + '_aug_{}'.format(args.data_aug) +
'_fold_{}'.format(args.fold) + '_seed_{}'.format(args.seed),
current_time + '_' + socket.gethostname())
writer = SummaryWriter(log_dir=tb_dir)
writer.add_text('Parameters', str(args))
temp_submissions_dir_train = os.path.join(temp_submissions_trial_dir,
'train')
temp_submissions_dir_valid = os.path.join(temp_submissions_trial_dir,
'valid')
logging.info('\n===> Training mode')
train_begin_time = timer()
batchNum_per_epoch = data_generator.batchNum_per_epoch
iterator = tqdm(enumerate(data_generator.generate_train()),
total=args.max_epochs * batchNum_per_epoch,
unit='batch')
for batch_idx, (batch_x, batch_y_dict) in iterator:
epoch = int(batch_idx // batchNum_per_epoch) + initial_epoch
batch_epoch = int(batch_idx % batchNum_per_epoch)
################
## Validation
################
if batch_idx % 200 == 0:
valid_begin_time = timer()
train_time = valid_begin_time - train_begin_time
# Train evaluation
shutil.rmtree(temp_submissions_dir_train, ignore_errors=True)
os.makedirs(temp_submissions_dir_train, exist_ok=False)
train_metrics = evaluation.evaluate(
data_generator=data_generator,
data_type='train',
max_audio_num=30,
task_type=args.task_type,
model=model,
cuda=args.cuda,
loss_type=loss_type,
threshold=threshold,
submissions_dir=temp_submissions_dir_train,
frames_per_1s=frames_per_1s,
sub_frames_per_1s=sub_frames_per_1s)
logging.info(
'------------------------------------------------------------------------------------------------------------------------------------'
)
# Validation evaluation
if args.fold != -1:
shutil.rmtree(temp_submissions_dir_valid, ignore_errors=True)
os.makedirs(temp_submissions_dir_valid, exist_ok=False)
valid_metrics = evaluation.evaluate(
data_generator=data_generator,
data_type='valid',
max_audio_num=30,
task_type=args.task_type,
model=model,
cuda=args.cuda,
loss_type=loss_type,
threshold=threshold,
submissions_dir=temp_submissions_dir_valid,
frames_per_1s=frames_per_1s,
sub_frames_per_1s=sub_frames_per_1s)
metrics = [train_metrics, valid_metrics]
logging_and_writer('valid', metrics, logging, writer,
batch_idx)
else:
logging_and_writer('train', train_metrics, logging, writer,
batch_idx)
valid_time = timer() - valid_begin_time
logging.info(
'Iters: {}, Epoch/Total epoch: {}/{}, Batch/Total batch per epoch: {}/{}, Train time: {:.3f}s, Eval time: {:.3f}s'
.format(batch_idx, epoch, args.max_epochs + initial_epoch,
batch_epoch, batchNum_per_epoch, train_time,
valid_time))
logging.info(
'------------------------------------------------------------------------------------------------------------------------------------'
)
train_begin_time = timer()
###############
## Save model
###############
if args.task_type == 'sed_only':
save_factor = 38 # 12
elif args.task_type == 'doa_only':
save_factor = 78 # 48
if ((batch_idx % (2 * batchNum_per_epoch))
== 0) and ((batch_idx + initial_epoch * batchNum_per_epoch) >=
save_factor * batchNum_per_epoch):
save_path = os.path.join(models_dir, 'epoch_{}.pth'.format(epoch))
checkpoint = {
'model_state_dict': model.module.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'rng_state': torch.get_rng_state(),
'cuda_rng_state': torch.cuda.get_rng_state(),
'epoch': epoch
}
torch.save(checkpoint, save_path)
logging.info('Checkpoint saved to {}'.format(save_path))
###############
## Train
###############
# Reduce learning rate
if args.task_type == 'sed_only':
reduce_factor = 26 # 12
elif args.task_type == 'doa_only':
reduce_factor = 48 # 48
if args.reduce_lr:
# if ((batch_idx % (batchNum_per_epoch)) == 0) and (batch_idx >= reduce_factor*batchNum_per_epoch):
# for param_group in optimizer.param_groups:
# param_group['lr'] *= 0.9
if (batch_idx + initial_epoch *
batchNum_per_epoch) >= reduce_factor * batchNum_per_epoch:
for param_group in optimizer.param_groups:
param_group['lr'] = 0.0001
batch_x = to_torch(batch_x, args.cuda)
batch_y_dict = {
'events': to_torch(batch_y_dict['events'], args.cuda),
'doas': to_torch(batch_y_dict['doas'], args.cuda)
}
if args.data_aug == 'mixup':
batch_x, batch_y_dict['events'] = mixup(batch_x,
batch_y_dict['events'],
alpha=0.1)
elif args.data_aug == 'specaug':
batch_x = freq_mask(batch_x,
ratio_F=0.1,
num_masks=2,
replace_with_zero=False)
batch_x = time_mask(batch_x,
ratio_T=0.1,
num_masks=2,
replace_with_zero=False)
elif args.data_aug == 'mixup&specaug':
batch_x, batch_y_dict['events'] = mixup(batch_x,
batch_y_dict['events'],
alpha=0.1)
batch_x = freq_mask(batch_x,
ratio_F=0.1,
num_masks=2,
replace_with_zero=False)
batch_x = time_mask(batch_x,
ratio_T=0.1,
num_masks=2,
replace_with_zero=False)
# Forward
model.train()
output = model(batch_x)
# Loss
seld_loss, _, _ = hybrid_regr_loss(output,
batch_y_dict,
args.task_type,
loss_type=loss_type)
# Backward
optimizer.zero_grad()
seld_loss.backward()
optimizer.step()
if batch_idx == args.max_epochs * batchNum_per_epoch:
iterator.close()
writer.close()
break
# Update the current state and score
current_state = next_state
score += reward
# Log episode data in the training csv
if done or t == args.max_episode_length - 1:
logger.to_csv(training_csv, [t, score])
logger.log("Length: %d; Score: %d\n" % (t + 1, score))
break
t += 1
# Evaluate the agent's performance
if frame_counter % args.test_freq == 0:
t_evaluation, score_evaluation = evaluate(DQA, args, logger)
# Log evaluation data
logger.to_csv(eval_csv, [t_evaluation, score_evaluation])
# Hold out a set of test states to monitor the mean Q value
if len(test_states) < args.test_states:
# Generate test states
for _ in range(random.randint(1, 5)):
test_states.append(DQA.get_random_state())
else:
# Update scores and mean Q values
test_scores.append(score)
test_q_values = [DQA.get_max_q(state) for state in test_states]
test_mean_q.append(np.mean(test_q_values))
episode += 1
# Update the current state and score
current_state = next_state
score += reward
# Log episode data in the training csv
if done or t == args.max_episode_length - 1:
logger.to_csv(training_csv, [t, score])
logger.log("Length: %d; Score: %d\n" % (t + 1, score))
break
t += 1
# Evaluate the agent's performance
if frame_counter % args.test_freq == 0:
t_evaluation, score_evaluation = evaluate(DQA, args, logger)
# Log evaluation data
logger.to_csv(eval_csv, [t_evaluation, score_evaluation])
# Hold out a set of test states to monitor the mean Q value
if len(test_states) < args.test_states:
# Generate test states
for _ in range(random.randint(1, 5)):
test_states.append(DQA.get_random_state())
else:
# Update scores and mean Q values
test_scores.append(score)
test_q_values = [DQA.get_max_q(state) for state in test_states]
test_mean_q.append(np.mean(test_q_values))
episode += 1
def train(train_file_path):
preprocessor = PreProcessor()
train_data, dev_data, vocab = preprocessor.get_train_and_dev(
train_file_path, GRAMMAR_FILE, PRIMITIVE_TYPES)
grammar = ASDLGrammar.grammar_from_text(
open(GRAMMAR_FILE).read(), PRIMITIVE_TYPES)
transition_system = TransitionSystem(grammar)
evaluator = ConalaEvaluator(transition_system)
model = TranxParser(vocab, transition_system)
model.train()
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=LR)
glorot_init(model.parameters())
epoch = train_iter = 0
report_loss = report_examples = report_sup_att_loss = 0.
history_dev_scores = []
num_trial = patience = 0
while True:
epoch += 1
epoch_begin = time.time()
for batch_examples in batch_iter(train_data, BATCH_SIZE):
train_iter += 1
optimizer.zero_grad()
ret_val = model.forward(batch_examples)
loss = -ret_val[0]
loss_val = torch.sum(loss).item()
report_loss += loss_val
report_examples += len(batch_examples)
loss = torch.mean(loss)
loss.backward()
optimizer.step()
if train_iter % 50 == 0:
log_str = '[Iter %d] encoder loss=%.5f' % (
train_iter, report_loss / report_examples)
print(log_str)
report_loss = report_examples = 0.
print('[Epoch %d] epoch elapsed %ds' %
(epoch, time.time() - epoch_begin))
model_file = SAVE_TO + '.iter%d.bin' % train_iter
print('save model to [%s]' % model_file)
model.save(model_file, saveGrammar=True)
# perform validation
#if epoch % args.valid_every_epoch == 0:
print('[Epoch %d] begin validation' % epoch)
eval_start = time.time()
eval_results = evaluation.evaluate(dev_data,
model,
evaluator,
BEAM_SIZE,
verbose=True)
dev_score = eval_results[evaluator.default_metric]
print('[Epoch %d] evaluate details: %s, dev %s: %.5f (took %ds)' %
(epoch, eval_results, evaluator.default_metric, dev_score,
time.time() - eval_start))
is_better = history_dev_scores == [] or dev_score >= max(
history_dev_scores)
history_dev_scores.append(dev_score)
if DECAY_LR_AFTER_EPOCH and epoch > DECAY_LR_AFTER_EPOCH:
lr = optimizer.param_groups[0]['lr'] * LR_DECAY
print('decay learning rate to %f' % lr)
# set new lr
for param_group in optimizer.param_groups:
param_group['lr'] = lr
if is_better:
patience = 0
model_file = SAVE_TO + '.bin'
print('save the current model ..')
print('save model to [%s]' % model_file)
model.save(model_file, True)
# also save the optimizers' state
torch.save(optimizer.state_dict(), SAVE_TO + '.optim.bin')
elif patience < PATIENCE and epoch >= DECAY_LR_AFTER_EPOCH:
patience += 1
print('hit patience %d' % patience)
if epoch == MAX_EPOCH:
print('reached max epoch, stop!')
exit(0)
if patience >= PATIENCE and epoch >= DECAY_LR_AFTER_EPOCH:
num_trial += 1
print('hit #%d trial' % num_trial)
if num_trial == MAX_NUM_TRIAL:
print('early stop!')
exit(0)
# decay lr, and restore from previously best checkpoint
lr = optimizer.param_groups[0]['lr'] * LR_DECAY
print('load previously best model and decay learning rate to %f' %
lr)
# load model
params = torch.load(SAVE_TO + '.bin',
map_location=lambda storage, loc: storage)
model.load_state_dict(params['state_dict'])
model.to(device)
# load optimizers
"""
if args.reset_optimizer:
print('reset optimizer')
optimizer = torch.optim.Adam(model.parameters(), lr=lr)
else:
print('restore parameters of the optimizers')
optimizer.load_state_dict(torch.load(SAVE_TO + '.optim.bin'))
"""
print('reset optimizer')
optimizer = torch.optim.Adam(model.parameters(), lr=lr)
# set new lr
for param_group in optimizer.param_groups:
param_group['lr'] = lr
# reset patience
patience = 0
data = data_processing('~/Downloads/sch_impact.csv')
# prepare the X, Y
X, Y = prepare_X_Y(data, 'target_exp_2')
# build the train and test samples
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.3)
# build the model
classifier = PredictMedianCitationsExist()
# train the model
classifier = classifier.train(10, 64, X_train, X_test, Y_train, Y_test, stopping=False)
# evaluate and print the training stats
model_evaluation = evaluate(classifier, 'train', x_train=X_train, y_train=Y_train)
# print training metrics
print('Training Loss:', model_evaluation[0])
print('Training Accuracy:', model_evaluation[1])
# print the test set metrcs [acc, prec, recall, f1]
model_evaluation = clf_metrics(classifier, x_test=X_test, y_test=Y_test)
# test accuracy
print('Test accuracy:', model_evaluation[0])
# precision
print('Precision:', model_evaluation[1])
# recall
def main():
parser = argparse.ArgumentParser(description="Run QA-CLEF-System")
parser.add_argument('--preprocess',action="store_true")
parser.add_argument('--train',action="store_true")
parser.add_argument('--answeronly',action='store_true')
parser.add_argument('--selftest',action='store_true')
parser.add_argument('--data',nargs = '+',default=[2011],type=int)
parser.add_argument('--test',nargs = '+',default=[2012],type=int)
parser.add_argument('--forcedownload',action='store_true')
parser.add_argument('--preprocessonly',action='store_true')
parser.add_argument('--ngram', type=int, default=3)
parser.add_argument('--threshold', type=float, default=0.5)
parser.add_argument('--report',action='store_true')
args = parser.parse_args()
process_args(args)
data = []
for edition in args.data + args.test:
_data = qacache.find_data(edition)
if args.preprocess or _data is None:
input_check([edition],args.forcedownload)
_data = input_parse([edition])
print >> sys.stderr, 'preprocessing ' + str(edition) + '-data'
_data = preprocessing.preprocess(_data)
qacache.store_preprocessed_data(edition,_data[0])
else:
print >> sys.stderr, str(edition) + '-data is found on cache/' + str(edition) + '-prerocessed.txt'
data.append(_data)
if args.preprocessonly:
print >> sys.stderr, 'Preprocess-only task is done.'
sys.exit(0)
# build-model
print >> sys.stderr, 'Building model...'
training_model = model_builder.build_model(data[:len(args.data)])
test_model = model_builder.build_model(data[-len(args.test):]) if len(args.test) != 0 and not args.selftest else []
# scoring
print >> sys.stderr, 'Unweighted Feature Scoring...'
training_model and scoring.score(training_model)
test_model and scoring.score(test_model)
# training
weight = qacache.stored_weight()
if args.train or weight is None:
print >> sys.stderr, 'Training...'
weight = train(training_model)
else:
print >> sys.stderr, 'Weight is found on cache/weight.txt'
# weighted_scoring
print >> sys.stderr, 'Weighted Feature Scoring...'
final = scoring.weighted_scoring(training_model if args.selftest else test_model, weight)
# answer selection
select_answer(final,args.threshold)
# evaluation
result = evaluate(final)
qacache.write_json(final,'final.txt',indent=True)
if args.report:
report(final, args.test if not args.selftest else args.data,weight)
print "Result: %f" % result
#print("{} Start test:".format(datetime.now()))
test_acc = 0.
test_count = 0
for _ in range(test_batches_per_epoch):
batch_tx1, batch_tx2, batch_ty = X_test_generator.next_batch(batch_size)
acc,predictions = sess.run([loss,score], feed_dict={x1: batch_tx1,
y: batch_ty,
keep_prob: 1.})
test_acc += acc
test_count += 1
a, p, r = eval.evaluate(batch_ty,predictions,k=1)
accu[0] += a
prec[0] += p
rec[0] += r
a, p, r = eval.evaluate(batch_ty,predictions,k=3)
accu[1] += a
prec[1] += p
rec[1] += r
a, p, r = eval.evaluate(batch_ty,predictions,k=5)
accu[2] += a
prec[2] += p
rec[2] += r
a, p, r = eval.evaluate(batch_ty,predictions,k=10)
def self_training(args):
"""Perform self-training
First load decoding results on disjoint data
also load pre-trained model and perform supervised
training on both existing training data and the
decoded results
"""
print('load pre-trained model from [%s]' % args.load_model, file=sys.stderr)
params = torch.load(args.load_model, map_location=lambda storage, loc: storage)
vocab = params['vocab']
transition_system = params['transition_system']
saved_args = params['args']
saved_state = params['state_dict']
# transfer arguments
saved_args.cuda = args.cuda
saved_args.save_to = args.save_to
saved_args.train_file = args.train_file
saved_args.unlabeled_file = args.unlabeled_file
saved_args.dev_file = args.dev_file
saved_args.load_decode_results = args.load_decode_results
args = saved_args
update_args(args)
model = Parser(saved_args, vocab, transition_system)
model.load_state_dict(saved_state)
if args.cuda: model = model.cuda()
model.train()
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
print('load unlabeled data [%s]' % args.unlabeled_file, file=sys.stderr)
unlabeled_data = Dataset.from_bin_file(args.unlabeled_file)
print('load decoding results of unlabeled data [%s]' % args.load_decode_results, file=sys.stderr)
decode_results = pickle.load(open(args.load_decode_results))
labeled_data = Dataset.from_bin_file(args.train_file)
dev_set = Dataset.from_bin_file(args.dev_file)
print('Num. examples in unlabeled data: %d' % len(unlabeled_data), file=sys.stderr)
assert len(unlabeled_data) == len(decode_results)
self_train_examples = []
for example, hyps in zip(unlabeled_data, decode_results):
if hyps:
hyp = hyps[0]
sampled_example = Example(idx='self_train-%s' % example.idx,
src_sent=example.src_sent,
tgt_code=hyp.code,
tgt_actions=hyp.action_infos,
tgt_ast=hyp.tree)
self_train_examples.append(sampled_example)
print('Num. self training examples: %d, Num. labeled examples: %d' % (len(self_train_examples), len(labeled_data)),
file=sys.stderr)
train_set = Dataset(examples=labeled_data.examples + self_train_examples)
print('begin training, %d training examples, %d dev examples' % (len(train_set), len(dev_set)), file=sys.stderr)
print('vocab: %s' % repr(vocab), file=sys.stderr)
epoch = train_iter = 0
report_loss = report_examples = 0.
history_dev_scores = []
num_trial = patience = 0
while True:
epoch += 1
epoch_begin = time.time()
for batch_examples in train_set.batch_iter(batch_size=args.batch_size, shuffle=True):
batch_examples = [e for e in batch_examples if len(e.tgt_actions) <= args.decode_max_time_step]
train_iter += 1
optimizer.zero_grad()
loss = -model.score(batch_examples)
# print(loss.data)
loss_val = torch.sum(loss).data[0]
report_loss += loss_val
report_examples += len(batch_examples)
loss = torch.mean(loss)
loss.backward()
# clip gradient
if args.clip_grad > 0.:
grad_norm = torch.nn.utils.clip_grad_norm(model.parameters(), args.clip_grad)
optimizer.step()
if train_iter % args.log_every == 0:
print('[Iter %d] encoder loss=%.5f' %
(train_iter,
report_loss / report_examples),
file=sys.stderr)
report_loss = report_examples = 0.
print('[Epoch %d] epoch elapsed %ds' % (epoch, time.time() - epoch_begin), file=sys.stderr)
# model_file = args.save_to + '.iter%d.bin' % train_iter
# print('save model to [%s]' % model_file, file=sys.stderr)
# model.save(model_file)
# perform validation
print('[Epoch %d] begin validation' % epoch, file=sys.stderr)
eval_start = time.time()
eval_results = evaluation.evaluate(dev_set.examples, model, args, verbose=True)
dev_acc = eval_results['accuracy']
print('[Epoch %d] code generation accuracy=%.5f took %ds' % (epoch, dev_acc, time.time() - eval_start), file=sys.stderr)
is_better = history_dev_scores == [] or dev_acc > max(history_dev_scores)
history_dev_scores.append(dev_acc)
if is_better:
patience = 0
model_file = args.save_to + '.bin'
print('save currently the best model ..', file=sys.stderr)
print('save model to [%s]' % model_file, file=sys.stderr)
model.save(model_file)
# also save the optimizers' state
torch.save(optimizer.state_dict(), args.save_to + '.optim.bin')
elif epoch == args.max_epoch:
print('reached max epoch, stop!', file=sys.stderr)
exit(0)
elif patience < args.patience:
patience += 1
print('hit patience %d' % patience, file=sys.stderr)
if patience == args.patience:
num_trial += 1
print('hit #%d trial' % num_trial, file=sys.stderr)
if num_trial == args.max_num_trial:
print('early stop!', file=sys.stderr)
exit(0)
# decay lr, and restore from previously best checkpoint
lr = optimizer.param_groups[0]['lr'] * args.lr_decay
print('load previously best model and decay learning rate to %f' % lr, file=sys.stderr)
# load model
params = torch.load(args.save_to + '.bin', map_location=lambda storage, loc: storage)
model.load_state_dict(params['state_dict'])
if args.cuda: model = model.cuda()
# load optimizers
if args.reset_optimizer:
print('reset optimizer', file=sys.stderr)
optimizer = torch.optim.Adam(model.inference_model.parameters(), lr=lr)
else:
print('restore parameters of the optimizers', file=sys.stderr)
optimizer.load_state_dict(torch.load(args.save_to + '.optim.bin'))
# set new lr
for param_group in optimizer.param_groups:
param_group['lr'] = lr
# reset patience
patience = 0
def learn(env, max_timesteps, timesteps_per_batch, clip_param):
ppo_epoch = 5
num_step = timesteps_per_batch
save_interval = 100
seed = 1000
batch_size = 64
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
log_dir = os.path.expanduser('/tmp/gym/')
eval_log_dir = log_dir + "_eval"
utils.cleanup_log_dir(log_dir)
utils.cleanup_log_dir(eval_log_dir)
torch.set_num_threads(1)
device = torch.device("cuda")
envs = make_vec_envs(env, seed, 8, 0.95, log_dir, device, False)
actor_critic = Policy(envs.observation_space.shape,
envs.action_space,
base_kwargs={'recurrent': False})
actor_critic.to(device)
agent = algo.PPO(actor_critic,
clip_param,
ppo_epoch,
batch_size,
0.5,
0.01,
lr=0.00025,
eps=1e-05,
max_grad_norm=0.5)
rollouts = RolloutStorage(num_step, 8, envs.observation_space.shape,
envs.action_space,
actor_critic.recurrent_hidden_state_size)
obs = envs.reset()
rollouts.obs[0].copy_(torch.tensor(obs))
rollouts.to(device)
episode_rewards = deque(maxlen=10)
start = time.time()
num_updates = int(max_timesteps) // num_step // 8
for j in range(num_updates):
# decrease learning rate linearly
utils.update_linear_schedule(agent.optimizer, j, num_updates, 0.00025)
for step in range(num_step):
# Sample actions
with torch.no_grad():
value, action, action_log_prob, recurrent_hidden_states = actor_critic.act(
rollouts.obs[step], rollouts.recurrent_hidden_states[step],
rollouts.masks[step])
# Obser reward and next obs
obs, reward, done, infos = envs.step(action)
for info in infos:
if 'episode' in info.keys():
episode_rewards.append(info['episode']['r'])
# If done then clean the history of observations.
masks = torch.FloatTensor([[0.0] if done_ else [1.0]
for done_ in done])
bad_masks = torch.FloatTensor(
[[0.0] if 'bad_transition' in info.keys() else [1.0]
for info in infos])
rollouts.insert(obs, recurrent_hidden_states, action,
action_log_prob, value, reward, masks, bad_masks)
with torch.no_grad():
next_value = actor_critic.get_value(
rollouts.obs[-1], rollouts.recurrent_hidden_states[-1],
rollouts.masks[-1]).detach()
rollouts.compute_returns(next_value, True, 0.99, 0.95, False)
value_loss, action_loss, dist_entropy = agent.update(rollouts)
rollouts.after_update()
# save for every interval-th episode or for the last epoch
if (j % save_interval == 0
or j == num_updates - 1) and "./trained_models/" != "":
save_path = os.path.join("./trained_models/", 'ppo')
try:
os.makedirs(save_path)
except OSError:
pass
torch.save([
actor_critic,
getattr(utils.get_vec_normalize(envs), 'ob_rms', None)
], os.path.join(save_path, 'UniversalPolicy' + ".pt"))
if j % 1 == 0 and len(episode_rewards) > 1:
total_num_steps = (j + 1) * 8 * num_step
end = time.time()
print(
"Updates {}, num timesteps {}, FPS {} \n Last {} training episodes: mean/median reward {:.1f}/{:.1f}, min/max reward {:.1f}/{:.1f}\n"
.format(j, total_num_steps,
int(total_num_steps / (end - start)),
len(episode_rewards), np.mean(episode_rewards),
np.median(episode_rewards), np.min(episode_rewards),
np.max(episode_rewards), dist_entropy, value_loss,
action_loss))
if (args.eval_interval is not None and len(episode_rewards) > 1
and j % args.eval_interval == 0):
ob_rms = utils.get_vec_normalize(envs).ob_rms
evaluate(actor_critic, ob_rms, args.env_name, args.seed,
args.num_processes, eval_log_dir, device)
'''
bow_feats=False, rel_feats=False)
print '\n\n\n bow performance: '
evaluate(args['data'], args['model'], args['d'], rnn_feats=False, \
bow_feats=True, rel_feats=False)
print '\n\n\n bow-dt performance: '
evaluate(args['data'], args['model'], args['d'], rnn_feats=False, \
bow_feats=True, rel_feats=True)
"""
parser = argparse.ArgumentParser(description='QANTA evaluation')
parser.add_argument('-data', help='location of dataset', default='util/data_semEval/final_input_restest800')
parser.add_argument('-model', help='location of trained model', default='models/trainingResBidir_params')
parser.add_argument('-d', help='word embedding dimension', type=int, default=100)
parser.add_argument('-len', help='training vector length', default = 50)
parser.add_argument('-c', help='number of classes', type=int, default=3)
parser.add_argument('-op', help='use mixed word vector or not', default = False)
args = vars(parser.parse_args())
print 'qanta performance: '
"""
evaluate(args['data'], args['model'], args['d'], rnn_feats=True, \
bow_feats=False, rel_feats=False)
"""
if args['op']:
eval.evaluate(args['data'], args['model'], args['d'] + args['len'], args['c'])
else:
eval.evaluate(args['data'], args['model'], args['d'], args['c'])
def main():
args = get_args()
torch.manual_seed(args.seed)
torch.cuda.manual_seed_all(args.seed)
if args.cuda and torch.cuda.is_available() and args.cuda_deterministic:
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True
args_dir, logs_dir, models_dir, samples_dir = get_all_save_paths(
args, 'pretrain', combine_action=args.combine_action)
eval_log_dir = logs_dir + "_eval"
utils.cleanup_log_dir(logs_dir)
utils.cleanup_log_dir(eval_log_dir)
_, _, intrinsic_models_dir, _ = get_all_save_paths(args,
'learn_reward',
load_only=True)
if args.load_iter != 'final':
intrinsic_model_file_name = os.path.join(
intrinsic_models_dir,
args.env_name + '_{}.pt'.format(args.load_iter))
else:
intrinsic_model_file_name = os.path.join(
intrinsic_models_dir, args.env_name + '.pt'.format(args.load_iter))
intrinsic_arg_file_name = os.path.join(args_dir, 'command.txt')
# save args to arg_file
with open(intrinsic_arg_file_name, 'w') as f:
json.dump(args.__dict__, f, indent=2)
torch.set_num_threads(1)
device = torch.device("cuda:0" if args.cuda else "cpu")
envs = make_vec_envs(args.env_name, args.seed, args.num_processes,
args.gamma, logs_dir, device, False)
actor_critic = Policy(envs.observation_space.shape,
envs.action_space,
base_kwargs={'recurrent': args.recurrent_policy})
actor_critic.to(device)
if args.algo == 'a2c':
agent = algo.A2C_ACKTR(actor_critic,
args.value_loss_coef,
args.entropy_coef,
lr=args.lr,
eps=args.eps,
alpha=args.alpha,
max_grad_norm=args.max_grad_norm)
elif args.algo == 'ppo':
agent = algo.PPO(actor_critic,
args.clip_param,
args.ppo_epoch,
args.num_mini_batch,
args.value_loss_coef,
args.entropy_coef,
lr=args.lr,
eps=args.eps,
max_grad_norm=args.max_grad_norm)
elif args.algo == 'acktr':
agent = algo.A2C_ACKTR(actor_critic,
args.value_loss_coef,
args.entropy_coef,
acktr=True)
else:
raise NotImplementedError
if args.use_intrinsic:
obs_shape = envs.observation_space.shape
if len(obs_shape) == 3:
action_dim = envs.action_space.n
elif len(obs_shape) == 1:
action_dim = envs.action_space.shape[0]
if 'NoFrameskip' in args.env_name:
file_name = os.path.join(
args.experts_dir, "trajs_ppo_{}.pt".format(
args.env_name.split('-')[0].replace('NoFrameskip',
'').lower()))
else:
file_name = os.path.join(
args.experts_dir,
"trajs_ppo_{}.pt".format(args.env_name.split('-')[0].lower()))
rff = RewardForwardFilter(args.gamma)
intrinsic_rms = RunningMeanStd(shape=())
if args.intrinsic_module == 'icm':
print('Loading pretrained intrinsic module: %s' %
intrinsic_model_file_name)
inverse_model, forward_dynamics_model, encoder = torch.load(
intrinsic_model_file_name)
icm = IntrinsicCuriosityModule(envs, device, inverse_model, forward_dynamics_model, \
inverse_lr=args.intrinsic_lr, forward_lr=args.intrinsic_lr,\
)
if args.intrinsic_module == 'vae':
print('Loading pretrained intrinsic module: %s' %
intrinsic_model_file_name)
vae = torch.load(intrinsic_model_file_name)
icm = GenerativeIntrinsicRewardModule(envs, device, \
vae, lr=args.intrinsic_lr, \
)
rollouts = RolloutStorage(args.num_steps, args.num_processes,
envs.observation_space.shape, envs.action_space,
actor_critic.recurrent_hidden_state_size)
obs = envs.reset()
rollouts.obs[0].copy_(obs)
rollouts.to(device)
episode_rewards = deque(maxlen=10)
start = time.time()
num_updates = int(
args.num_env_steps) // args.num_steps // args.num_processes
for j in range(num_updates):
if args.use_linear_lr_decay:
# decrease learning rate linearly
utils.update_linear_schedule(
agent.optimizer, j, num_updates,
agent.optimizer.lr if args.algo == "acktr" else args.lr)
for step in range(args.num_steps):
with torch.no_grad():
value, action, action_log_prob, recurrent_hidden_states = actor_critic.act(
rollouts.obs[step], rollouts.recurrent_hidden_states[step],
rollouts.masks[step])
obs, reward, done, infos = envs.step(action)
next_obs = obs
for info in infos:
if 'episode' in info.keys():
episode_rewards.append(info['episode']['r'])
# If done then clean the history of observations.
masks = torch.FloatTensor([[0.0] if done_ else [1.0]
for done_ in done])
bad_masks = torch.FloatTensor(
[[0.0] if 'bad_transition' in info.keys() else [1.0]
for info in infos])
rollouts.insert(obs, next_obs, recurrent_hidden_states, action,
action_log_prob, value, reward, masks, bad_masks)
with torch.no_grad():
next_value = actor_critic.get_value(
rollouts.obs[-1], rollouts.recurrent_hidden_states[-1],
rollouts.masks[-1]).detach()
if args.use_intrinsic:
for step in range(args.num_steps):
state = rollouts.obs[step]
action = rollouts.actions[step]
next_state = rollouts.next_obs[step]
if args.intrinsic_module == 'icm':
state = encoder(state)
next_state = encoder(next_state)
with torch.no_grad():
rollouts.rewards[
step], pred_next_state = icm.calculate_intrinsic_reward(
state, action, next_state, args.lambda_true_action)
if args.standardize == 'True':
buf_rews = rollouts.rewards.cpu().numpy()
intrinsic_rffs = np.array(
[rff.update(rew) for rew in buf_rews.T])
rffs_mean, rffs_std, rffs_count = mpi_moments(
intrinsic_rffs.ravel())
intrinsic_rms.update_from_moments(rffs_mean, rffs_std**2,
rffs_count)
mean = intrinsic_rms.mean
std = np.asarray(np.sqrt(intrinsic_rms.var))
rollouts.rewards = rollouts.rewards / torch.from_numpy(std).to(
device)
rollouts.compute_returns(next_value, args.use_gae, args.gamma,
args.gae_lambda, args.use_proper_time_limits)
value_loss, action_loss, dist_entropy = agent.update(rollouts)
rollouts.after_update()
# save for every interval-th episode or for the last epoch
if (j % args.save_interval == 0
or j == num_updates - 1) and args.save_dir != "":
save_path = os.path.join(models_dir, args.algo)
policy_file_name = os.path.join(save_path, args.env_name + '.pt')
try:
os.makedirs(save_path)
except OSError:
pass
torch.save([
actor_critic,
getattr(utils.get_vec_normalize(envs), 'ob_rms', None)
], policy_file_name)
if j % args.log_interval == 0 and len(episode_rewards) > 1:
total_num_steps = (j + 1) * args.num_processes * args.num_steps
end = time.time()
print(
"{} Updates {}, num timesteps {}, FPS {} \n Last {} training episodes: mean/median reward {:.1f}/{:.1f}, min/max reward {:.1f}/{:.1f}\n"
.format(args.env_name, j, total_num_steps,
int(total_num_steps / (end - start)),
len(episode_rewards), np.mean(episode_rewards),
np.median(episode_rewards), np.min(episode_rewards),
np.max(episode_rewards), dist_entropy, value_loss,
action_loss))
if (args.eval_interval is not None and len(episode_rewards) > 1
and j % args.eval_interval == 0):
ob_rms = utils.get_vec_normalize(envs).ob_rms
evaluate(actor_critic, ob_rms, args.env_name, args.seed,
args.num_processes, eval_log_dir, device)
if __name__ == '__main__':
db_file = sys.argv[1]
db = loadmat(db_file, squeeze_me=True)['store']['s'].item()
PRF = collections.namedtuple('PRF', 'p r f pcw rcw fcw')
divergences = ['KL', 'IS', 'EU']
seqs = {}
prfs = collections.defaultdict(lambda: collections.defaultdict(list))
for i in range(db.shape[0]):
print db[i]['name'].item()
K = len(db[i]['classNames'].item())
ground_truth = db[i]['trueLabel'].item() - 1 # for 0-indexing
X = db[i]['feature'].item()
for div in divergences:
seqs[div] = cluster(X, K, div, debug=False)
for algo in seqs[div]:
prfs[algo][div].append(PRF(*evaluation.evaluate(ground_truth, seqs[div][algo], K)))
# print '{}: {}'.format(div, prfs[algo][div][-1])
prf = collections.defaultdict(dict)
for algo in prfs:
for div in divergences:
prf[algo][div] = PRF(*[np.array(vals) for vals in zip(*prfs[algo][div])])
print
print algo
for div in divergences:
print '{}: {}'.format(div, PRF(*['{:.3f} +/- {:.3f}'.format(x.mean(), x.std())
for x in prf[algo][div]]))
# loop over all frames from the split file
for index, (sample_id, bev_maps, targets) in enumerate(data_loader):
print(index, " of ", len(data_loader))
# Stores detections for each image index
img_detections = []
# Targets position and dimension values are between 0 - 1, so that they
# have to be transformed to pixel coordinates
targets[:, 2:] *= cnf.BEV_WIDTH
if opt.estimate_bb:
# detects objects
predictions = detector(model, bev_maps, opt)
img_detections.extend(predictions)
# Calculate if the prediction is a true detection
if opt.evaluate:
ngt += len(targets)
sample_metrics += get_batch_statistics_rotated_bbox(predictions, targets, opt.iou_thres)
# Visualization of the ground truth and if estimated the predicted boxes
if opt.visualize:
visualize_func(bev_maps[0], targets, img_detections, sample_id, opt.estimate_bb)
if opt.estimate_bb and opt.evaluate:
# Concatenate sample statistics
true_positives, pred_scores = [np.concatenate(x, 0) for x in list(zip(*sample_metrics))]
ap_all, ap_11 = evaluate(true_positives, pred_scores, ngt)
print("Approximation of the average precision (AP).\nAll point approximation: %.3f.\n11 point approximation: %.3f." %(ap_all, ap_11))
def test_simple_full_training(test_session):
m = models['Simple']
rv = m.Predictor(test_session, test=True).predict()
report_data = evaluate(rv)
print(report_static_test(report_data, flag='Full'))
a = classification_report(dev_y, preds)
print(acc_score)
print(conf_mat)
print(f1)
print(a)
'''
for i in range(len(preds)):
predictions[str(test_df['tweet_id'][i])] = preds[i]
else:
# test_y = lb.fit_transform(test_df.sentiment)
# test_y = test_y.argmax(axis=1)
valid_seq_x = sequence.pad_sequences(token.texts_to_sequences(
test_df.tweet_text),
maxlen=32)
# predict the labels on validation dataset
preds = model.predict(valid_seq_x)
preds = preds.argmax(axis=1)
for i in range(len(preds)):
if preds[i] == 2:
predictions[str(test_df['tweet_id'][i])] = 'positive'
elif preds[i] == 1:
predictions[str(test_df['tweet_id'][i])] = 'neutral'
else:
predictions[str(test_df['tweet_id'][i])] = 'negative'
# a = classification_report(test_y, preds)
# print(a)
#predictions = {'163361196206957578': 'neutral', '768006053969268950': 'neutral', '742616104384772304': 'neutral', '102313285628711403': 'neutral', '653274888624828198': 'neutral'} # TODO: Remove this line, 'predictions' should be populated with the outputs of your classifier
evaluation.evaluate(predictions, testset, classifier)
evaluation.confusion(predictions, testset, classifier)
def main():
"""
Analyzes specified documents.
"""
options = parse_args()
print options
# we assume there exist three files:
# a vocab file (corpus_vocab.dat)
# a training file (corpus_train.dat)
# a validation file (corpus_test.dat)
corpus = options.corpus
# vocab file
W = len(open(corpus + "_vocab.dat", 'r').readlines())
# validation file
validation_filename = corpus + "_test.dat"
wikirandom = archived_dataset.Corpus(corpus + "_train.dat") # should be _train.dat
# else:
# import wikirandom
#load a held-out set
validation_docs = archived_dataset.loadDocs(validation_filename)
algorithmname = options.algorithmname
# the second tells us the batch size
batchsize = options.batchsize
# the third tells us a list of number of threads to run. (each will be run sequentially)
numthreads = options.numthreads
# number of documents
trueD = wikirandom._D
if(algorithmname == "hbb"):
if options.D == -1:
D = trueD # number of documents to know in advance
else:
D = options.D
# #prior for topics (ANDRE: this is now a parameter)
# eta = 1.
eta = options.eta
# The total number of documents
#D = 3.3e6 (used to be number in Wikipedia; now an argument)
# The number of topics
K = options.K
alpha = 1./K #* numpy.ones(K)
batchsize = options.batchsize
if (algorithmname == "hdp_filtering"):
alg = filtering.HDPFiltering(W,eta, options.max_iters,options.threshold*1E-6, T = 300, K = 30)
if (algorithmname == "ss"):
if (numthreads == 1):
alg = filtering.Filtering(W, K, alpha, eta, 1, True, 0.1) # note: last two args shouldn't matter
else:
# NOT REALLY SUPPORTED!
alg = parallelfiltering.ParallelFiltering(W, K, alpha, eta, 1, 0.1,True,options.numthreads)
if (algorithmname == "filtering"):
#maxiters = 15
if (numthreads == 1):
alg = filtering.Filtering(W, K, alpha, eta, options.max_iters, options.useHBBBound, options.threshold)
else:
if (options.async):
alg = asynchronous.ParallelFiltering(W, K, alpha, eta, options.max_iters, options.threshold, options.useHBBBound, options.batchsize, options.numthreads)
batchsize = batchsize * options.async_batches_per_eval * options.numthreads
else:
alg = parallelfiltering.ParallelFiltering(W, K, alpha, eta, options.max_iters, options.threshold, options.useHBBBound, options.numthreads, options.batchsize)
batchsize = batchsize * options.numthreads
if (algorithmname == "hbb"):
#default: tau0 = 1024; kappa = 0.7
# paper says: kappa = 0.5; tau0 = 64; S (minibatch size) = 4096
# alg = onlineldavb.OnlineLDA(W, K, D, alpha, 1./K, options.tau0, options.kappa) # the original code for NIPS submission, eta = 1/K
alg = onlineldavb.OnlineLDA(W, K, D, alpha, eta, options.tau0, options.kappa)
# EP for LDA
if (algorithmname == "filtering_ep"):
if (numthreads == 1):
alg = filtering.FilteringEP(W, K, alpha, eta, options.max_iters, options.threshold, options.useNewton)
else:
if (options.async):
alg = asynchronous.ParallelFilteringEP(W, K, alpha, eta, options.max_iters, options.threshold, options.useNewton, options.batchsize, options.numthreads)
batchsize = batchsize * options.async_batches_per_eval * options.numthreads
else:
alg = parallelfiltering.ParallelFilteringEP(W, K, alpha, eta, options.max_iters, options.threshold, options.useNewton, options.numthreads, options.batchsize)
batchsize = batchsize * options.numthreads
# Fake EP for LDA (?) -- to be removed eventually since it's worse than true EP
if (algorithmname == "filtering_ep2"):
if (numthreads == 1):
alg = filtering.FilteringEP2(W, K, alpha, eta, options.max_iters, options.threshold, options.useNewton)
else:
if (options.async):
alg = asynchronous.ParallelFilteringEP2(W, K, alpha, eta, options.max_iters, options.threshold, options.useNewton, options.batchsize, options.numthreads)
batchsize = batchsize * options.async_batches_per_eval * options.numthreads
else:
alg = parallelfiltering.ParallelFilteringEP2(W, K, alpha, eta, options.max_iters, options.threshold, options.useNewton, options.numthreads, options.batchsize)
batchsize = batchsize * options.numthreads
# Specify the minimum number of points to be processed before we run the evaluation code, since evaluation is expensive
minNumPtsPerEval = options.minNumPtsPerEval
expGrowthEval = options.expGrowthEval
if (minNumPtsPerEval <= 0):
if (corpus == "nature"): # 351K docs
minNumPtsPerEval = 512 #1e3
elif (corpus == "wiki"): # 3.6M docs
minNumPtsPerEval = 512 #1e3 #2e4
else:
minNumPtsPerEval = int(trueD / 1000)
print "Using algorithm: " + str(alg)
recordedData = []
totalTime = 0.0
totalDownloadingTime = 0.0
iters = int(trueD / batchsize) + 1
numPtsProc = 0 # number of points processed since last evaluation
for iteration in range(iters):
# Get some articles
start = time.time()
docset = wikirandom.get_random_docs(batchsize)
totalDownloadingTime += time.time() - start
start = time.time()
(alg_alpha, alg_lam) = alg.update_lambda(docset)
iter_time = time.time() - start
totalTime += iter_time
numPtsProc += batchsize # we have processed this many more points
if (numPtsProc >= minNumPtsPerEval or iteration == iters-1): # evaluate if we have processed enough points, or this is the last iteration
numPtsProc = 0 # reset the counter
# The following is just the usual evaluation code from before
start = time.time()
(perplex, split) = evaluation.evaluate(validation_docs, alg_alpha, alg_lam, options.usePtEst)
testTime = time.time() - start
print str(iteration+1) + "/" + str(iters) + " " + str(alg) + " (%g, %g): held-out perplexity estimate = %f, %f" % (iter_time, testTime, perplex, split)
recordedData += [((iteration+1)*batchsize, totalTime, totalDownloadingTime, perplex, split)] # also save perplexity now!
if (algorithmname in ["hbb", "filtering", "filtering_ep", "filtering_ep2"]):
outfile = corpus + "_" + str(alg) + "_" + str(batchsize) + "_eta" + str(eta) # need to distinguish eta now
else:
outfile = corpus + "_" + algorithmname + "_" + str(options.batchsize) + "_" + str(options.numthreads) + "_eta" + str(eta)
numpy.save(outfile, recordedData)
if (expGrowthEval):
# double the number of points to the next evaluation
minNumPtsPerEval = minNumPtsPerEval * 2
else:
print str(iteration+1) + "/" + str(iters) + " " + str(alg) + " (%g)" % (iter_time)
if (iteration == iters-1):
# save final lambda matrix
if (algorithmname in ["hbb", "filtering", "filtering_ep", "filtering_ep2"]):
topics_outfile = "topics_" + corpus + "_" + str(alg) + "_" + str(batchsize) + "_eta" + str(eta) # need to distinguish eta now
else:
topics_outfile = "topics_" + corpus + "_" + algorithmname + "_" + str(options.batchsize) + "_" + str(options.numthreads)
numpy.save(topics_outfile, alg_lam)
# asynchronous filtering needs to terminate its workers
if (algorithmname == "filtering"):
if (numthreads > 1):
if (options.async):
alg.shutdown()
print "DONE!"
wv_mean = test.tweet.apply(tweet_vectors,
args=(300, 'mean')).apply(pd.Series)
test = pd.concat([test, wv_sum, wv_mean], axis=1)
X_test = scaler.transform(
test.drop(['id', 'tweet', 'target', 'label'], axis=1))
elif classifier == 'combined_model':
for func in process_funcs:
data.tweet = data.tweet.apply(func)
X_test = tfidf_vect.transform(test.tweet)
test['count_pos'], test['count_neg'], \
test['count_neu']= zip(*test.tweet.apply(count_opinon_lexicons2, args=(wp, wn, stopWords)))
wv_sum_test = test.tweet.apply(tweet_vectors,
args=(300, 'sum')).apply(pd.Series)
wv_mean_test = test.tweet.apply(tweet_vectors,
args=(300,
'mean')).apply(pd.Series)
counts_test = scaler.transform(
test[['count_pos', 'count_neg', 'count_neu']])
X_test = hstack(
[X_test, wv_sum_test.values, wv_mean_test.values, counts_test])
# creating predictions dictionary
test_pred = sentiment_clf.predict(X=X_test)
target_names = list(target_dict.keys())
predictions = dict(
zip(test['id'].values, map(lambda x: target_names[x], test_pred)))
evaluation.evaluate(predictions, test_path, classifier)
evaluation.confusion(predictions, test_path, classifier)
def main():
args = get_args()
trace_size = args.trace_size
toke = tokenizer(args)
torch.manual_seed(args.seed)
torch.cuda.manual_seed_all(args.seed)
if args.cuda and torch.cuda.is_available() and args.cuda_deterministic:
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True
log_dir = os.path.expanduser(args.log_dir)
eval_log_dir = log_dir + "_eval"
utils.cleanup_log_dir(log_dir)
utils.cleanup_log_dir(eval_log_dir)
torch.set_num_threads(1)
device = torch.device("cuda:0" if args.cuda else "cpu")
envs = make_vec_envs(args.env_name, args.seed, args.num_processes,
args.gamma, args.log_dir, device, False)
actor_critic = Policy(envs.observation_space.shape,
envs.action_space,
base_kwargs={'recurrent': args.recurrent_policy})
actor_critic.to(device)
if args.algo == 'a2c':
agent = algo.A2C_ACKTR(actor_critic,
args.value_loss_coef,
args.entropy_coef,
lr=args.lr,
eps=args.eps,
alpha=args.alpha,
max_grad_norm=args.max_grad_norm)
elif args.algo == 'ppo':
agent = algo.PPO(actor_critic,
args.clip_param,
args.ppo_epoch,
args.num_mini_batch,
args.value_loss_coef,
args.entropy_coef,
lr=args.lr,
eps=args.eps,
max_grad_norm=args.max_grad_norm)
elif args.algo == 'acktr':
agent = algo.A2C_ACKTR(actor_critic,
args.value_loss_coef,
args.entropy_coef,
acktr=True)
rollouts = RolloutStorage(args.num_steps, args.num_processes,
envs.observation_space.shape, envs.action_space,
actor_critic.recurrent_hidden_state_size)
obs = envs.reset()
tobs = torch.zeros((args.num_processes, trace_size), dtype=torch.long)
#print (tobs.dtype)
rollouts.obs[0].copy_(obs)
rollouts.tobs[0].copy_(tobs)
rollouts.to(device)
episode_rewards = deque(maxlen=args.num_processes)
start = time.time()
num_updates = int(
args.num_env_steps) // args.num_steps // args.num_processes
save_path = os.path.join(args.save_dir, args.algo)
if args.load:
actor_critic.load_state_dict = (os.path.join(save_path,
args.env_name + ".pt"))
for j in range(num_updates):
if args.use_linear_lr_decay:
# decrease learning rate linearly
utils.update_linear_schedule(
agent.optimizer, j, num_updates,
agent.optimizer.lr if args.algo == "acktr" else args.lr)
for step in range(args.num_steps):
# Sample actions
with torch.no_grad():
value, action, action_log_prob, recurrent_hidden_states = actor_critic.act(
rollouts.obs[step], rollouts.tobs[step],
rollouts.recurrent_hidden_states[step],
rollouts.masks[step])
# Obser reward and next obs
obs, reward, done, infos = envs.step(action)
tobs = []
envs.render()
for info in infos:
if 'episode' in info.keys():
#print ("episode ", info['episode'])
episode_rewards.append(info['episode']['r'])
trace = info['trace'][0:trace_size]
trace = [x[2] for x in trace]
word_to_ix = toke.tokenize(trace)
seq = prepare_sequence(trace, word_to_ix)
if len(seq) < trace_size:
seq = torch.zeros((trace_size), dtype=torch.long)
seq = seq[:trace_size]
#print (seq.dtype)
tobs.append(seq)
tobs = torch.stack(tobs)
#print (tobs)
#print (tobs.size())
# If done then clean the history of observations.
masks = torch.FloatTensor([[0.0] if done_ else [1.0]
for done_ in done])
bad_masks = torch.FloatTensor(
[[0.0] if 'bad_transition' in info.keys() else [1.0]
for info in infos])
rollouts.insert(obs, tobs, recurrent_hidden_states, action,
action_log_prob, value, reward, masks, bad_masks)
with torch.no_grad():
next_value = actor_critic.get_value(
rollouts.obs[-1], rollouts.tobs[-1],
rollouts.recurrent_hidden_states[-1],
rollouts.masks[-1]).detach()
rollouts.compute_returns(next_value, args.use_gae, args.gamma,
args.gae_lambda, args.use_proper_time_limits)
value_loss, action_loss, dist_entropy = agent.update(rollouts)
rollouts.after_update()
# save for every interval-th episode or for the last epoch
#"""
if (j % args.save_interval == 0
or j == num_updates - 1) and args.save_dir != "":
save_path = os.path.join(args.save_dir, args.algo)
try:
os.makedirs(save_path)
except OSError:
pass
torch.save([
actor_critic,
getattr(utils.get_vec_normalize(envs), 'ob_rms', None)
], os.path.join(save_path, args.env_name + ".pt"))
pickle.dump(toke.word_to_ix, open("save.p", "wb"))
#"""
if j % args.log_interval == 0 and len(episode_rewards) > 1:
total_num_steps = (j + 1) * args.num_processes * args.num_steps
end = time.time()
print(
"Updates {}, num timesteps {}, FPS {} \n Last {} training episodes: mean/median reward {:.1f}/{:.1f}, min/max reward {:.1f}/{:.1f}\n"
.format(j, total_num_steps,
int(total_num_steps / (end - start)),
len(episode_rewards), np.mean(episode_rewards),
np.median(episode_rewards), np.min(episode_rewards),
np.max(episode_rewards), dist_entropy, value_loss,
action_loss))
writer.add_scalar(
'mean reward',
np.mean(episode_rewards),
total_num_steps,
)
writer.add_scalar(
'median reward',
np.median(episode_rewards),
total_num_steps,
)
writer.add_scalar(
'max reward',
np.max(episode_rewards),
total_num_steps,
)
if (args.eval_interval is not None and len(episode_rewards) > 1
and j % args.eval_interval == 0):
ob_rms = utils.get_vec_normalize(envs).ob_rms
evaluate(actor_critic, ob_rms, args.env_name, args.seed,
args.num_processes, eval_log_dir, device)
def evaluate(self, target_dir):
return evaluation.evaluate(self.submitted_survey_dir, target_dir)
