def load_dataset(dataset):
'''
Returns two numpy arrays (x, y) in which:
x : is the data matrix of (num_examples, num_covariates)
y : is a two column array containing the censor and time variables for each row in x
'''
## Define internal functions
def format_to_optunity(dataset, strata=False):
'''
Formats a dataset dictionary containing survival data with keys:
{
'x' : baseline data
'e' : censor
't' : event time
}
to a format that Optunity can use to run hyper-parameter searches on.
'''
x = dataset['x']
e = dataset['e']
t = dataset['t']
y = np.column_stack((e, t))
# Take the indices of censored entries as strata
if strata:
strata = [np.nonzero(np.logical_not(e).astype(np.int32))[0].tolist()]
else:
strata = None
return (x,y,strata)
def load_simulated_dataset(dataset):
# Default values
NUM_EXAMPLES = 5000
treatment_group = False
hr_ratio = 5
# Check if experiment is treatment group
if dataset == 'treatment':
hr_ratio = 10
treatment_group = True
dataset = 'gaussian'
# Generate Data
factory = datasets.SimulatedData(hr_ratio=hr_ratio,
average_death=5,
censor_mode = 'observed_p', observed_p = .5,
num_features=10, num_var=2,
treatment_group=treatment_group)
ds = factory.generate_data(NUM_EXAMPLES, method=dataset)
return ds
# Simulated Data Experiments
if dataset in ['linear', 'gaussian', 'treatment']:
ds = load_simulated_dataset(dataset)
else:
# If not a simulated dataset, load the dataset
ds = utils.load_datasets(dataset)['train']
return format_to_optunity(ds)
def __init__(self, splits):
self.error_margin = 3.0
self.splits = splits
self.gt = {}
self.instr_ids = []
self.scans = []
for item in load_datasets(splits):
self.gt[item['path_id']] = item
self.scans.append(item['scan'])
self.instr_ids += ['%d_%d' % (item['path_id'],i) for i in range(3)]
self.scans = set(self.scans)
self.instr_ids = set(self.instr_ids)
self.graphs = load_nav_graphs(self.scans)
self.distances = {}
for scan,G in self.graphs.iteritems(): # compute all shortest paths
self.distances[scan] = dict(nx.all_pairs_dijkstra_path_length(G))
def __init__(self, feature_store, batch_size=100, seed=10, splits=['train'], tokenizer=None):
self.env = EnvBatch(feature_store=feature_store, batch_size=batch_size)
self.data = []
self.scans = []
for item in load_datasets(splits):
# Split multiple instructions into separate entries
for j,instr in enumerate(item['instructions']):
self.scans.append(item['scan'])
new_item = dict(item)
new_item['instr_id'] = '%s_%d' % (item['path_id'], j)
new_item['instructions'] = instr
if tokenizer:
new_item['instr_encoding'] = tokenizer.encode_sentence(instr)
self.data.append(new_item)
self.scans = set(self.scans)
self.splits = splits
self.seed = seed
random.seed(self.seed)
random.shuffle(self.data)
self.ix = 0
self.batch_size = batch_size
self._load_nav_graphs()
print 'R2RBatch loaded with %d instructions, using splits: %s' % (len(self.data), ",".join(splits))
def main():
with open(params_path + 'params_' + args.dataset + '.json') as f:
params = json.load(f)
print(params)
CI_list = np.zeros(n_runs)
loss_list = np.zeros(n_runs)
tic = time.time()
for i in range(n_runs):
dataset_name = dataset_path+'/'+dataset_type+'/'+str(i)+raw_datafile
print(dataset_name)
datasets = utils.load_datasets(dataset_path+'/'+dataset_type+'/'+raw_datafile)
train_data = datasets['train']
norm_vals = {
'mean' : datasets['train']['x'].mean(axis=0),
'std' : datasets['train']['x'].std(axis=0)
}
test_data = datasets['test']
print(params['standardize'])
if params['standardize'] == True:
train_data = utils.standardize_dataset(datasets['train'], norm_vals['mean'], norm_vals['std'])
valid_data = utils.standardize_dataset(datasets['valid'], norm_vals['mean'], norm_vals['std'])
test_data = utils.standardize_dataset(datasets['test'], norm_vals['mean'], norm_vals['std'])
print('dataset shape: \n')
print('train x: {}, valid x: {}, test x: {}'.format(train_data['x'].shape, valid_data['x'].shape, test_data['x'].shape))
print('train e: {}, valid e: {}, test e: {}'.format(train_data['e'].shape, valid_data['e'].shape, test_data['e'].shape))
print('train t: {}, valid t: {}, test t: {}'.format(train_data['t'].shape, valid_data['t'].shape, test_data['t'].shape))
train_X = train_data['x']
train_y = {'e': train_data['e'], 't': train_data['t']}
valid_X = valid_data['x']
valid_y = {'e': valid_data['e'], 't': valid_data['t']}
test_X = test_data['x']
test_y = {'e': test_data['e'], 't': test_data['t']}
input_nodes = train_X.shape[1]
output_nodes = 1
test_data = {}
valid_data = {}
'''
test_data['X'], test_data['E'], \
test_data['T'], test_data['failures'], \
test_data['atrisk'], test_data['ties'] = utils.parse_data(test_X, test_y)
'''
test_data['X'], test_data['E'], \
test_data['T'] = utils.prepare_data(test_X, test_y)
test_data['ties']='noties'
valid_data['X'], valid_data['E'], \
valid_data['T'] = utils.prepare_data(valid_X, valid_y)
valid_data['ties']='noties'
test_label = {'t': test_data['T'], 'e': test_data['E']}
valid_label = {'t': valid_data['T'], 'e': valid_data['E']}
model = L2DeepSurv(train_X, train_y, valid_X, valid_y,
input_nodes, output_nodes, **params)
output_dir = save_dir + '/run_' + str(i)
if not os.path.exists(output_dir) and not args.debug:
os.makedirs(output_dir)
with open(os.path.join(output_dir + 'params.json'), 'w') as outfile:
json.dump(params, outfile)
# Plot curve of loss and CI on train data
model.train(num_epoch=2000, iteration=100,
plot_loss=True, plot_CI=True, plot_gate=True, output_dir=output_dir)
test_CI, test_loss = model.eval(test_data['X'], test_label)
fin_val_CI, fin_val_loss = model.eval(valid_data['X'], valid_label)
CI_list[i] = test_CI
loss_list[i] = test_loss
np.save(output_dir+'CI_list', CI_list)
np.save(output_dir+'loss_list', loss_list)
print("final valid CI: {}".format(fin_val_CI))
print("final valid loss: {}".format(fin_val_loss))
print("average test CI over {} runs: {}".format(n_runs, CI_list.mean()))
print("average test loss over {} runs: {}".format(n_runs, loss_list.mean()))
tac = time.time()
print("Time: {}".format(tac - tic))
def __init__(self,
feature_store,
batch_size=100,
seed=10,
splits=['train'],
tokenizer=None,
path_type='planner_path',
history='target'):
self.env = EnvBatch(feature_store=feature_store, batch_size=batch_size)
datasets = load_datasets(splits)
self.data = []
self.scans = [item['scan'] for item in datasets]
self._load_nav_graphs()
for item in datasets:
# For every dialog history, stitch together a single instruction string.
new_item = dict(item)
new_item['inst_idx'] = item['inst_idx']
if history == 'target' or len(
item['dialog_history']
) == 0: # Have to use target only if no dialog history.
tar = item['target']
new_item['instructions'] = '<TAR> ' + tar
if tokenizer:
new_item['instr_encoding'] = tokenizer.encode_sentence(
[tar], seps=['<TAR>'])
elif history == 'oracle_ans':
ora_a = item['dialog_history'][-1][
'message'] # i.e., the last oracle utterance.
tar = item['target']
new_item['instructions'] = '<ORA> ' + ora_a + ' <TAR> ' + tar
if tokenizer:
new_item['instr_encoding'] = tokenizer.encode_sentence(
[ora_a, tar], seps=['<ORA>', '<TAR>'])
elif history == 'nav_q_oracle_ans':
nav_q = item['dialog_history'][-2]['message']
ora_a = item['dialog_history'][-1]['message']
tar = item['target']
new_item[
'instructions'] = '<NAV> ' + nav_q + ' <ORA> ' + ora_a + ' <TAR> ' + tar
if tokenizer:
qa_enc = tokenizer.encode_sentence(
[nav_q, ora_a, tar], seps=['<NAV>', '<ORA>', '<TAR>'])
new_item['instr_encoding'] = qa_enc
elif history == 'all':
dia_inst = ''
sentences = []
seps = []
for turn in item['dialog_history']:
sentences.append(turn['message'])
sep = '<NAV>' if turn['role'] == 'navigator' else '<ORA>'
seps.append(sep)
dia_inst += sep + ' ' + turn['message'] + ' '
sentences.append(item['target'])
seps.append('<TAR>')
dia_inst += '<TAR> ' + item['target']
new_item['instructions'] = dia_inst
if tokenizer:
dia_enc = tokenizer.encode_sentence(sentences, seps=seps)
new_item['instr_encoding'] = dia_enc
# TODO: add a flag to enable/disable nav history
new_item['nav_hist_encoding'] = []
for nav_idx, pano in enumerate(item['nav_history']):
view_index = 0
if nav_idx + 1 < len(item['nav_history']):
next_pano = item['nav_history'][nav_idx + 1]
pos = self.graphs[item['scan']].node[pano]['position']
next_pos = self.graphs[
item['scan']].node[next_pano]['position']
target_rel = next_pos - pos
target_heading = math.pi / 2.0 - math.atan2(
target_rel[1], target_rel[0])
if target_heading < 0:
target_heading += math.pi * 2
view_index = int(
round(target_heading / HEADING_INCREMENT) + 12)
feature = self.env.features[item['scan'] + '_' +
pano][view_index, :]
new_item['nav_hist_encoding'].append(pano + '_' +
str(view_index))
new_item['nav_hist_encoding'].reverse()
new_item['nav_hist_encoding'] = tokenizer.pad_or_trunc_sequence(
new_item['nav_hist_encoding'], NAV_HIST_SEQ_LENGTH, "")
self.data.append(new_item)
self.scans = set(self.scans)
self.splits = splits
self.seed = seed
random.seed(self.seed)
random.shuffle(self.data)
self.ix = 0
self.batch_size = batch_size
self.path_type = path_type
print 'R2RBatch loaded with %d instructions, using splits: %s' % (len(
self.data), ",".join(splits))
output_file = os.path.join(output_dir,
'_'.join(['rsf', TIMESTRING, 'rec_surv.pdf']))
viz.plot_survival_curves(experiment_name='RSF',
output_file=output_file,
**rec_dict)
if __name__ == '__main__':
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
args = parse_args()
print("Arguments:", args)
# Load Dataset
print("Loading datasets: " + args.dataset)
datasets = utils.load_datasets(args.dataset)
# Train CPH model
print("Training CPH Model")
train_df = utils.format_dataset_to_df(datasets['train'], DURATION_COL,
EVENT_COL)
cf = CoxPHFitter()
results = cf.fit(train_df,
duration_col=DURATION_COL,
event_col=EVENT_COL,
include_likelihood=True)
cf.print_summary()
print("Train Likelihood: " + str(cf._log_likelihood))
if 'valid' in datasets:
metrics = evaluate_model(cf, datasets['valid'])
def train(self, epoch, train_env, tb_logger=None):
batch_time = AverageMeter()
losses = AverageMeter()
dists = AverageMeter()
movements = AverageMeter()
val_losses = AverageMeter()
val_acces = AverageMeter()
print('Training on {} env ...'.format(train_env.splits[0]))
# switch to train mode
self.agent.env = train_env
self.agent.encoder.train()
self.agent.model.train()
if self.opts.second_training:
self.agent.model.first_stage_model.training = False
self.agent.feedback = self.opts.feedback_training
self.agent.value_loss = None
self.agent.val_acc = None
# load dataset path for computing ground truth distance
self.agent.gt = {}
for item in load_datasets(train_env.splits, self.opts):
self.agent.gt[item['path_id']] = item
end = time.time()
for iter in range(1, self.train_iters_epoch + 1):
# rollout the agent
if self.opts.arch == 'self-monitoring':
loss, traj = self.agent.rollout_monitor()
elif self.opts.arch == 'speaker-baseline':
loss, traj = self.agent.rollout()
else:
raise NotImplementedError()
dist_from_goal = np.mean(self.agent.dist_from_goal)
movement = np.mean(self.agent.traj_length)
losses.update(loss.item(), self.opts.batch_size)
dists.update(dist_from_goal, self.opts.batch_size)
movements.update(movement, self.opts.batch_size)
if self.agent.value_loss is not None:
val_losses.update(self.agent.value_loss.item(),
self.opts.batch_size)
if self.agent.val_acc is not None:
val_acces.update(np.mean(self.agent.val_acc),
self.opts.batch_size)
# zero the gradients before backward pass
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if tb_logger and iter % 10 == 0:
current_iter = iter + (epoch - 1) * self.train_iters_epoch
tb_logger.add_scalar('train/loss_train', loss, current_iter)
tb_logger.add_scalar('train/dist_from_goal', dist_from_goal,
current_iter)
tb_logger.add_scalar('train/movements', movement, current_iter)
if self.agent.value_loss is not None:
tb_logger.add_scalar('train/value_loss',
self.agent.value_loss, current_iter)
print('Epoch: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'.format(
epoch,
iter,
self.train_iters_epoch,
batch_time=batch_time,
loss=losses))
if tb_logger:
tb_logger.add_scalar('epoch/learning_rate',
self.optimizer.param_groups[0]['lr'], epoch)
tb_logger.add_scalar('epoch/train/loss', losses.avg, epoch)
tb_logger.add_scalar('epoch/train/dist_from_goal', dists.avg,
epoch)
tb_logger.add_scalar('epoch/train/movements', movements.avg, epoch)
if self.agent.value_loss is not None:
tb_logger.add_scalar('epoch/train/val_loss', val_losses.avg,
epoch)
if self.agent.val_acc is not None:
tb_logger.add_scalar('epoch/train/val_acc', val_acces.avg,
epoch)
'''This is the repo which contains the original code to the WACV 2021 paper "Same Same But DifferNet: Semi-Supervised Defect Detection with Normalizing Flows" by Marco Rudolph, Bastian Wandt and Bodo Rosenhahn. For further information contact Marco Rudolph ([email protected])''' import config as c from train import * from utils import load_datasets, make_dataloaders import time import gc import json _, _, test_set = load_datasets(c.dataset_path, c.class_name, test=True) _, _, test_loader = make_dataloaders(None, None, test_set, test=True) model = torch.load("models/" + c.modelname + "", map_location=torch.device('cpu')) with open('models/' + c.modelname + '.json') as jsonfile: model_parameters = json.load(jsonfile) time_start = time.time() test(model, model_parameters, test_loader) time_end = time.time() time_c = time_end - time_start # 运行所花时间 print("test time cost: {:f} s".format(time_c))
def train(self, epoch, train_env, tb_logger=None):
batch_time = AverageMeter()
losses = AverageMeter()
dists = AverageMeter()
movements = AverageMeter()
val_losses = AverageMeter()
val_acces = AverageMeter()
aux_losses = AverageMeter()
accuracy = AverageMeter()
print('Training on {} env ...'.format(train_env.splits[0]))
# switch to train mode
self.agent.env = train_env
self.agent.encoder.train()
self.agent.model.train()
self.agent.feedback = self.opts.feedback_training
self.agent.value_loss = None
self.agent.val_acc = None
self.agent.rollback_attn = None
# load dataset path for computing ground truth distance
self.agent.gt = {}
for item in load_datasets(train_env.splits, self.opts):
self.agent.gt[item['path_id']] = item
success_count, rollback_success_count, rollback_count, oscillating_success_count, oscillating_count = 0, 0, 0, 0, 0
end = time.time()
for iter in range(1, self.train_iters_epoch + 1):
# roll out the agent
if self.opts.arch == 'regretful':
loss, traj, categories = self.agent.rollout_regret()
elif self.opts.arch == 'self-monitoring':
loss, traj, categories = self.agent.rollout_monitor()
elif self.opts.arch == 'speaker-baseline':
loss, traj = self.agent.rollout()
else:
raise NotImplementedError()
# Calculate aux task accuracy
acc = []
for gt, predicted in zip(categories[0], categories[1]):
max_index = predicted.max(dim=1)[1]
acc.append(
((max_index == gt).sum().item()) / (max_index.size()[0]))
acc = np.mean(acc) * 100
dist_from_goal = np.mean(self.agent.dist_from_goal)
movement = np.mean(self.agent.traj_length)
accuracy.update(acc, self.opts.batch_size)
losses.update(loss.item(), self.opts.batch_size)
dists.update(dist_from_goal, self.opts.batch_size)
movements.update(movement, self.opts.batch_size)
if self.agent.value_loss is not None:
val_losses.update(self.agent.value_loss.item(),
self.opts.batch_size)
if self.agent.val_acc is not None:
val_acces.update(np.mean(self.agent.val_acc),
self.opts.batch_size)
if self.agent.aux_loss is not None:
aux_losses.update(self.agent.aux_loss.item(),
self.opts.batch_size)
# zero the gradients before backward pass
self.optimizer.zero_grad()
loss.backward()
self.optimizer.step()
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if self.agent.rollback_attn is not None:
if iter == 1:
rollback_attn = self.agent.rollback_attn
else:
rollback_attn = np.concatenate(
(rollback_attn, self.agent.rollback_attn), axis=1)
if tb_logger and iter % 10 == 0:
current_iter = iter + (epoch - 1) * self.train_iters_epoch
tb_logger.add_scalar('train/loss_train', loss, current_iter)
tb_logger.add_scalar('train/dist_from_goal', dist_from_goal,
current_iter)
tb_logger.add_scalar('train/movements', movement, current_iter)
tb_logger.add_scalar('train/aux_accuracy', acc, current_iter)
if self.agent.value_loss is not None:
tb_logger.add_scalar('train/value_loss',
self.agent.value_loss, current_iter)
print('Epoch: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'.format(
epoch,
iter,
self.train_iters_epoch,
batch_time=batch_time,
loss=losses))
success_count, rollback_success_count, rollback_count, oscillating_success_count, oscillating_count = \
count_rollback_success(success_count, rollback_success_count, rollback_count, oscillating_success_count,
oscillating_count, traj)
if tb_logger:
tb_logger.add_scalar('epoch/learning_rate',
self.optimizer.param_groups[0]['lr'], epoch)
tb_logger.add_scalar('epoch/train/loss', losses.avg, epoch)
tb_logger.add_scalar('epoch/train/dist_from_goal', dists.avg,
epoch)
tb_logger.add_scalar('epoch/train/movements', movements.avg, epoch)
tb_logger.add_scalar('epoch/train/aux_accuracy', accuracy.avg,
epoch)
if self.agent.value_loss is not None:
tb_logger.add_scalar('epoch/train/val_loss', val_losses.avg,
epoch)
if self.agent.val_acc is not None:
tb_logger.add_scalar('epoch/train/val_acc', val_acces.avg,
epoch)
if self.agent.rollback_attn is not None:
for step in range(self.opts.max_episode_len):
tb_logger.add_histogram(
'epoch_train/rollback_attn_{}'.format(step),
rollback_attn[step], epoch)
if self.agent.aux_loss is not None:
tb_logger.add_scalar('epoch/train/aux_loss', aux_losses.avg,
epoch)
tb_logger.add_scalar('rollback_oscillation/train/rollback',
rollback_count / len(train_env.data), epoch)
tb_logger.add_scalar('rollback_oscillation/train/rollback_SR',
rollback_success_count / len(train_env.data),
epoch)
tb_logger.add_scalar('rollback_oscillation/train/oscillating',
oscillating_count / len(train_env.data),
epoch)
tb_logger.add_scalar(
'rollback_oscillation/train/oscillating_SR',
oscillating_success_count / len(train_env.data), epoch)
POST_POWER_DICT[key] = p_dic[key]['power'] if 'power' in p_dic[key] else 1
with open(CONFIG['inflect_templates_path'], 'rb') as f:
inflect_templates = pickle.load(f)
with open(CONFIG['tags_path'], 'rb') as f:
tpl_cls_dict = pickle.load(f)
lemma_cls_dict = {}
for lemma_tpl in inflect_templates:
lemma_id = tpl_cls_dict[lemma_tpl]['i']
for tpl in inflect_templates[lemma_tpl]:
lemma_cls_dict[tpl_cls_dict[tpl]['i']] = lemma_id
lemma_dict = {}
for item in load_datasets('inflect', 'test', 'train', 'valid'):
if item['id'] not in lemma_dict:
lemma_dict[item['id']] = (item['x_src'], item['x_cls'])
ad_tags_dict = {}
with open(VECT_PATH, 'rb') as f:
vec_words = pickle.load(f)
for word in vec_words:
item = vec_words[word]
for form in item['forms']:
lexeme_id_key = 'inflect_id' if 'inflect_id' in form else 'id'
lexeme_id = form[lexeme_id_key]
if 'ad_tags' not in form:
continue
clf = make_pipeline(SMOTE(random_state=0), LinearSVC(random_state=0))
clf.fit(X, y)
plot_decision_function(X, y, clf, ax[1], '(b)')
fig.tight_layout()
plt.savefig(join(analysis_path, 'resampling_decision_function.pdf'),
bbox_inches='tight',
pad_inches=0)
if __name__ == '__main__':
data_path, results_path, analysis_path = generate_paths()
# load datasets
datasets = load_datasets(data_dir=data_path)
# load results
results = []
for name in RESULTS_NAMES:
file_path = join(results_path, f'{name}.pkl')
results.append(pd.read_pickle(file_path))
# combine and select results
results = combine_results(*results)
results = select_results(results,
oversamplers_names=OVRS_NAMES,
classifiers_names=CLFS_NAMES)
# datasets description
summarize_multiclass_datasets(datasets).to_csv(join(
rec_dict = utils.calculate_recs_and_antirecs(rec_trt, true_trt = trt_idx, dataset = dataset)
output_file = os.path.join(output_dir, '_'.join(['deepsurv',TIMESTRING, 'rec_surv.pdf']))
print(output_file)
viz.plot_survival_curves(experiment_name = 'DeepSurv', output_file=output_file, **rec_dict)
def save_model(model, output_file):
model.save_weights(output_file)
if __name__ == '__main__':
args = parse_args()
print("Arguments:",args)
# Load Dataset
print("Loading datasets: " + args.dataset)
datasets = utils.load_datasets(args.dataset)
norm_vals = {
'mean' : datasets['train']['x'].mean(axis =0),
'std' : datasets['train']['x'].std(axis=0)
}
# Train Model
# TODO standardize location of logs + results => have them go into same directory with same UUID of experiment
tensor_log_dir = "/shared/data/logs/tensorboard_" + str(args.dataset) + "_" + str(uuid.uuid4())
logger = TensorboardLogger("experiments.deep_surv", tensor_log_dir, update_freq = 10)
model = deep_surv.load_model_from_json(args.model, args.weights)
if 'valid' in datasets:
valid_data = datasets['valid']
else:
valid_data = None
if create_features:
result = subprocess.run('python create_features.py', shell=True)
if result.returncode != 0:
print('ERROR: create_features.py')
quit()
# create_features.py された特徴量のリストを取得(今は使ってない)
parser = argparse.ArgumentParser()
parser.add_argument('--config', default='features.json')
options = parser.parse_args()
feat_dict = json.load(open(options.config))
use_features = feat_dict['features']
# loading
path = cwd.replace(this_folder, '/features')
train_df, test_df = load_datasets(path, is_debug)
# 欠損値処理
train_df, test_df = removeMissingColumns(train_df, test_df, 0.5)
logging.debug("Train shape: {}, test shape: {}".format(train_df.shape,
test_df.shape))
# model
"""
models, model_params, feature_importance_df, train_preds, test_preds, scores, model_name = kfold_lightgbm_without_outliers(
train_df, test_df, target_col=target_col, model_loss=loss_type,
num_folds=folds, feats_exclude=feats_exclude, stratified=False, use_gpu=use_GPU)
"""
models, model_params, feature_importance_df, train_preds, test_preds, scores, model_name = kfold_lightgbm(
train_df,
test_df,
def pre_train(args):
writer = SummaryWriter()
model_G = Generator()
model_G = nn.DataParallel(model_G)
model_G = model_G.to(device)
optim_G = torch.optim.Adam(model_G.parameters(),
lr=0.0002,
betas=(0.5, 0.999))
loss_G = nn.L1Loss().to(device)
result = {}
result["train/mae_loss"] = []
result["valid/mae_loss"] = []
train_dataset = load_datasets(args.train_data, args.batch_size,
args.patch_size, True)
valid_dataset = load_datasets(args.valid_data, args.batch_size,
args.patch_size, True)
for i in range(args.pre_epochs):
mae_loss = []
for (real_color, input_gray, hint_color), _ in tqdm(train_dataset):
real_color = real_color.to(device)
input_gray = input_gray.to(device)
hint_color = hint_color.to(device)
optim_G.zero_grad()
fake_color = model_G(input_gray, hint_color)
g_loss = loss_G(fake_color, real_color)
g_loss.backward()
optim_G.step()
mae_loss.append(g_loss.item())
result["train/mae_loss"].append(statistics.mean(mae_loss))
writer.add_scalar("pre_train/train/mae_loss",
result["train/mae_loss"][-1], i + 1)
if (i + 1) % 1 == 0 or (i + 1) == args.epochs or i == 0:
with torch.no_grad():
mae_loss = []
for (real_color, input_gray,
hint_color), _ in tqdm(valid_dataset):
batch_len = len(real_color)
real_color = real_color.to(device)
input_gray = input_gray.to(device)
hint_color = hint_color.to(device)
fake_color = model_G(input_gray, hint_color)
g_loss = loss_G(fake_color, real_color)
mae_loss.append(g_loss.item())
result["valid/mae_loss"].append(statistics.mean(mae_loss))
writer.add_scalar("pre_train/valid/mae_loss",
result["valid/mae_loss"][-1], i + 1)
torchvision.utils.save_image(real_color[:min(batch_len, 50)],
os.path.join(
args.pre_image_path,
f"real_epoch_{i + 1:03}.png"),
nrow=5,
range=(-1.0, 1.0),
normalize=True)
torchvision.utils.save_image(fake_color[:min(batch_len, 50)],
os.path.join(
args.pre_image_path,
f"fake_epoch_{i + 1:03}.png"),
nrow=5,
range=(-1.0, 1.0),
normalize=True)
torchvision.utils.save_image(hint_color[:min(batch_len, 50)],
os.path.join(
args.pre_image_path,
f"hint_epoch_{i + 1:03}.png"),
nrow=5,
range=(-1.0, 1.0),
normalize=True)
torch.save(
model_G.state_dict(),
os.path.join(args.pre_model_path, f"gen_{i + 1:03}.pt"))
writer.close()
def train(args):
writer = SummaryWriter()
model_name = get_model_name(args.pre_model_path)
print("loading...{}".format(model_name))
model_G, model_D = Generator(), Discriminator(args.patch_size)
model_G, model_D = nn.DataParallel(model_G), nn.DataParallel(model_D)
model_G.load_state_dict(torch.load(model_name))
model_G, model_D = model_G.to(device), model_D.to(device)
optim_G = torch.optim.Adam(model_G.parameters(),
lr=0.0002,
betas=(0.5, 0.999))
optim_D = torch.optim.Adam(model_D.parameters(),
lr=0.0002,
betas=(0.5, 0.999))
loss_bce = nn.BCEWithLogitsLoss()
loss_mse = nn.MSELoss()
ones = torch.ones(512, 1, args.patch_size // 16,
args.patch_size // 16).to(device)
zeros = torch.zeros(512, 1, args.patch_size // 16,
args.patch_size // 16).to(device)
result = {}
result["train/total_loss_G"] = []
result["train/total_loss_D"] = []
result["valid/total_loss_G"] = []
result["valid/total_loss_D"] = []
train_dataset = load_datasets(args.train_data, args.batch_size,
args.patch_size, True)
valid_dataset = load_datasets(args.valid_data, args.batch_size,
args.patch_size, True)
for i in range(args.epochs):
total_loss_G, total_loss_D = [], []
for (real_color, input_gray, hint_color), _ in tqdm(train_dataset):
batch_len = len(real_color)
real_color = real_color.to(device)
input_gray = input_gray.to(device)
hint_color = hint_color.to(device)
optim_D.zero_grad()
optim_G.zero_grad()
fake_color = model_G(input_gray, hint_color)
fake_color_tensor = fake_color.detach()
fake_D = model_D(fake_color)
g_mse_loss = loss_mse(real_color, fake_color)
g_bce_loss = loss_bce(fake_D, ones[:batch_len])
g_loss = args.LAMBDA * g_mse_loss + g_bce_loss
g_loss.backward(retain_graph=True)
optim_G.step()
total_loss_G.append(g_loss.item())
real_D_out = model_D(real_color)
fake_D_out = model_D(fake_color_tensor)
d_real_loss = loss_bce(real_D_out, ones[:batch_len])
d_fake_loss = loss_bce(fake_D_out, zeros[:batch_len])
d_loss = d_real_loss + d_fake_loss
d_loss.backward()
optim_D.step()
total_loss_D.append(d_loss.item())
result["train/total_loss_G"].append(statistics.mean(total_loss_G))
result["train/total_loss_D"].append(statistics.mean(total_loss_D))
writer.add_scalar('train/loss_G', result['train/total_loss_G'][-1],
i + 1)
writer.add_scalar('train/loss_D', result['train/total_loss_D'][-1],
i + 1)
if (i + 1) % 1 == 0 or (i + 1) == args.epochs or i == 0:
with torch.no_grad():
total_loss_G, total_loss_D = [], []
for (real_color, input_gray,
hint_color), _ in tqdm(valid_dataset):
batch_len = len(real_color)
real_color = real_color.to(device)
input_gray = input_gray.to(device)
hint_color = hint_color.to(device)
fake_color = model_G(input_gray, hint_color)
fake_color_tensor = fake_color.detach()
fake_D = model_D(fake_color)
g_mse_loss = loss_mse(real_color, fake_color)
g_bce_loss = loss_bce(fake_D, ones[:batch_len])
g_loss = args.LAMBDA * g_mse_loss + g_bce_loss
total_loss_G.append(g_loss.item())
real_D_out = model_D(real_color)
fake_D_out = model_D(fake_color_tensor)
d_real_loss = loss_bce(real_D_out, ones[:batch_len])
d_fake_loss = loss_bce(fake_D_out, zeros[:batch_len])
d_loss = d_real_loss + d_fake_loss
total_loss_D.append(d_loss.item())
result["valid/total_loss_G"].append(
statistics.mean(total_loss_G))
result["valid/total_loss_D"].append(
statistics.mean(total_loss_D))
writer.add_scalar('valid/loss_G',
result['valid/total_loss_G'][-1], i + 1)
writer.add_scalar('valid/loss_D',
result['valid/total_loss_D'][-1], i + 1)
torchvision.utils.save_image(real_color[:min(batch_len, 50)],
os.path.join(
args.image_path,
f"real_epoch_{i + 1:03}.png"),
nrow=5,
range=(-1.0, 1.0),
normalize=True)
torchvision.utils.save_image(fake_color[:min(batch_len, 50)],
os.path.join(
args.image_path,
f"fake_epoch_{i + 1:03}.png"),
nrow=5,
range=(-1.0, 1.0),
normalize=True)
torchvision.utils.save_image(hint_color[:min(batch_len, 50)],
os.path.join(
args.image_path,
f"hint_epoch_{i + 1:03}.png"),
nrow=5,
range=(-1.0, 1.0),
normalize=True)
torch.save(model_G.state_dict(),
os.path.join(args.model_path, f"gen_{i + 1:03}.pt"))
torch.save(model_D.state_dict(),
os.path.join(args.model_path, f"dis_{i + 1:03}.pt"))
writer.close()
import torch
from utils import load_datasets
from runner import Runner
import numpy as np
train_dataset, val_dataset, test_dataset = load_datasets()
encoder_file = input("Encoder file: ")
decoder_file = input("Decoder file: ")
encoder = torch.load("./{}".format(encoder_file))
decoder = torch.load("./{}".format(decoder_file))
runner = Runner(encoder, decoder, train_dataset, val_dataset, test_dataset)
bleu1, bleu4, test_loss = runner.test()
print("\n --- Test scores --- \nBleu 1: {} \nBleu4: {} \nLoss: {} \nPerplexity: {}"
.format(bleu1, bleu4, test_loss, np.exp(test_loss)))
def __init__(self,
opts,
features,
img_spec,
batch_size=64,
seed=10,
splits=['train'],
tokenizer=None):
self.env = PanoEnvBatch(features, img_spec, batch_size=batch_size)
self.data = []
self.scans = []
self.opts = opts
print('Loading {} dataset'.format(splits[0]))
json_data = load_datasets(splits)
total_length = len(json_data)
# iteratively load data into system memory
for i, item in enumerate(json_data):
if not is_experiment() and i >= 20: break
# Split multiple instructions into separate entries
for j, instr in enumerate(item['instructions']):
self.scans.append(item['scan'])
new_item = dict(item)
new_item['instr_id'] = '%s_%d' % (item['path_id'], j)
new_item['instructions'] = instr
if tokenizer:
if 'instr_encoding' not in item: # we may already include 'instr_encoding' when generating synthetic instructions
new_item['instr_encoding'] = tokenizer.encode_sentence(
instr)
else:
new_item['instr_encoding'] = item['instr_encoding']
if 'divide' in opts.lang_embed:
if opts.divide_method == 'kevin':
new_item[
'divid_instr_encoding'] = tokenizer.divide_instr_kevin(
instr, opts.max_sentence_segs)
else:
new_item[
'divid_instr_encoding'] = tokenizer.divide_instr_victor(
instr, opts.max_sentence_segs)
self.data.append(new_item)
print_progress(i + 1,
total_length,
prefix='Progress:',
suffix='Complete',
bar_length=50)
self.scans = set(self.scans)
self.splits = splits
self.seed = seed
random.seed(self.seed)
random.shuffle(self.data)
self.ix = 0
self.batch_size = batch_size
self._load_nav_graphs()
print('R2RBatch loaded with %d instructions, using splits: %s' %
(len(self.data), ",".join(splits)))
now = dt.datetime.now()
handler2 = logging.FileHandler(
filename="./logs/sub_{0:%Y%m%d%H%M%S}.log".format(now))
logger.addHandler(handler2)
IDNAME = config["ID_name"] if "ID_NAME" in config else "id"
RANDOM_STATE = 0
random.seed(RANDOM_STATE)
np.random.seed(RANDOM_STATE)
features = config["features"]
logger.info(features)
target_name = config["target_name"]
logger.info("load datasets")
X_train_all, X_test, dims = load_datasets(features)
indexes = [
f"{str_func(k)}{i}" if v > 1 else str_func(k) for k, v in dims.items()
for i in range(v)
]
y_train_all = load_target(target_name)
logger.info(X_train_all.shape)
fmeasures = []
y_preds = []
params = config["params"]
model_name = config["model_name"]
def __init__(self,
feature_store,
nav_graphs,
panoramic,
action_space,
encoder_type,
beam_size=1,
batch_size=100,
seed=10,
splits=['train'],
tokenizer=None,
att_ctx_merge='None',
min_n_sentences=-1): # , subgoal
self.env = EnvBatch(feature_store=feature_store,
batch_size=batch_size,
beam_size=beam_size)
self.data = []
self.scans = []
self.panoramic = panoramic
self.nav_graphs = nav_graphs
self.action_space = action_space
#self.ctrl_feature = ctrl_feature
self.ctrl_feature = None
self.att_ctx_merge = att_ctx_merge
self.traj_n_sents = {
} # for EncoderMultiLSTM and trajectories that have more than 3 instructions
if tokenizer:
tokname = tokenizer.__class__.__name__
data_dict = {
} # to merge instructions for same path scattered in different splits
for item in load_datasets(splits, encoder_type):
self.att_ctx_merge = att_ctx_merge
if self.att_ctx_merge == 'None' or self.att_ctx_merge == 'Eval':
j_offset = 0
while '%s_%d' % (item['path_id'], j_offset) in data_dict:
j_offset += 1
for j, instr in enumerate(item['instructions']):
self.scans.append(item['scan'])
new_item = dict(item)
new_item['instr_id'] = '%s_%d' % (item['path_id'],
j + j_offset)
if self.att_ctx_merge == 'None':
new_item['instructions'] = instr
elif self.att_ctx_merge == 'Eval':
new_item['instructions'] = [instr]
if tokenizer:
if self.att_ctx_merge == 'None':
new_item[
'instr_encoding'] = tokenizer.encode_sentence(
instr)
elif self.att_ctx_merge == 'Eval':
new_item['instr_encoding'] = [
tokenizer.encode_sentence(instr)
]
#self.data.append(new_item)
data_dict[new_item['instr_id']] = new_item
self.traj_n_sents[item['path_id']] = j + j_offset + 1
else:
self.scans.append(item['scan'])
if tokenizer:
instr_encoding = [
tokenizer.encode_sentence(instr)
for instr in item['instructions']
]
if str(item['path_id']) not in data_dict:
new_item = dict(item)
new_item['instr_id'] = str(item['path_id'])
data_dict[new_item['instr_id']] = new_item
self.traj_n_sents[new_item['instr_id']] = 0
if tokenizer: new_item['instr_encoding'] = []
else:
new_item = data_dict[str(item['path_id'])]
new_item['instructions'].extend(item['instructions'])
if tokenizer: new_item['instr_encoding'].extend(instr_encoding)
self.traj_n_sents[new_item['instr_id']] += len(
item['instructions'])
sent_max_len = 0
for traj in data_dict.values():
if len(traj['instr_encoding']) < min_n_sentences:
print('ignore path_id', traj['path_id'], 'with only',
len(traj['instr_encoding']), 'instructions')
continue
#sent_max_len = max(sent_max_len, max([len(tokenizer.split_sentence(instr)) for instr in traj['instructions']]))
sent_max_len = max(
sent_max_len,
max([len(instr.split(' ')) for instr in traj['instructions']]))
if min_n_sentences <= 0 or self.att_ctx_merge == 'None':
self.data.append(traj)
else:
# add permutations to get more instruction groups
for id_ix, id_perm in enumerate(
list(
combinations(
list(range(len(traj['instr_encoding']))),
min_n_sentences))):
new_traj = dict()
new_traj['instr_id'] = traj['instr_id'] + '_' + str(id_ix)
new_traj['instructions'] = list(
itemgetter(*id_perm)(traj['instructions']))
new_traj['instr_encoding'] = list(
itemgetter(*id_perm)(traj['instr_encoding']))
new_traj['distance'] = traj['distance']
new_traj['scan'] = traj['scan']
new_traj['path_id'] = traj['path_id']
new_traj['path'] = traj['path']
new_traj['heading'] = traj['heading']
self.data.append(new_traj)
if len(self.data) % 100000 == 0:
print('%d instructions' % (len(self.data)))
print(
'Average n_sentences:',
sum([i for i in self.traj_n_sents.values()]) /
len(self.traj_n_sents))
print('Max sentence length:', sent_max_len)
self.scans = set(self.scans)
self.splits = splits
if seed != 'resume':
self.seed = seed
random.seed(self.seed)
random.shuffle(self.data)
self.ix = 0
self.batch_size = batch_size
self._load_nav_graphs()
self.epo_inc = False # jolin: middle of an epoch
#self.env.pre_loadSims(self.data) # debug
print('R2RBatch loaded with %d instructions, using splits: %s' %
(len(self.data), ",".join(splits)))
#prepare the log file
now = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
logger = logging.getLogger('main')
logger.setLevel(logging.DEBUG)
sc = logging.StreamHandler()
logger.addHandler(sc)
fh = logging.FileHandler(f'logs/log_{now}.log')
logger.addHandler(fh)
logger.debug(f'logs/log_{now}.log')
logger.debug(config_path)
#load in datasets and target
feats = config['feats']
target_name = config['target_name']
train, test = load_datasets(feats)
target = load_target(target_name)
molecule_name = feather.read_dataframe(
'./data/input/train.feather')['molecule_name'].values
if is_debug_mode:
print("Debug mode is ON!")
train = train.iloc[:10000]
test = test.iloc[:1000]
target = target.iloc[:10000]
molecule_name = molecule_name[:10000]
train_type = train['type'].values
test_type = test['type'].values
logger.debug(feats)
def load_data(self):
train = pd.read_csv("./data/raw/train.csv")
X_train, X_test = load_datasets(self.features)
y_train = train["target"].to_frame()
return X_train, X_test, y_train
'''This is the repo which contains the original code to the WACV 2021 paper "Same Same But DifferNet: Semi-Supervised Defect Detection with Normalizing Flows" by Marco Rudolph, Bastian Wandt and Bodo Rosenhahn. For further information contact Marco Rudolph ([email protected])''' import config as c from train import * from utils import load_datasets, make_dataloaders import time import gc train_set, validate_set, _ = load_datasets(c.dataset_path, c.class_name) train_loader, validate_loader, _ = make_dataloaders(train_set, validate_set, None) time_start = time.time() model, model_parameters = train(train_loader, validate_loader) #model, model_config = train(train_loader, None) time_end = time.time() time_c = time_end - time_start # 运行所花时间 print("train time cost: {:f} s".format(time_c)) # free memory del train_set del validate_set del train_loader del validate_loader gc.collect() torch.cuda.empty_cache()
def eval(self, epoch, val_env, tb_logger=None):
batch_time = AverageMeter()
losses = AverageMeter()
dists = AverageMeter()
movements = AverageMeter()
val_losses = AverageMeter()
val_acces = AverageMeter()
aux_losses = AverageMeter()
accuracy = AverageMeter()
env_name, (env, evaluator) = val_env
print('Evaluating on {} env ...'.format(env_name))
self.agent.env = env
self.agent.env.reset_epoch()
self.agent.model.eval()
self.agent.encoder.eval()
self.agent.feedback = self.opts.feedback
self.agent.value_loss = None
self.agent.val_acc = None
self.agent.rollback_attn = None
# load dataset path for computing ground truth distance
self.agent.gt = {}
for item in load_datasets([env_name]):
self.agent.gt[item['path_id']] = item
val_iters_epoch = math.ceil(len(env.data) / self.opts.batch_size)
self.agent.results = {}
looped = False
iter = 1
success_count, rollback_success_count, rollback_count, oscillating_success_count, oscillating_count = 0, 0, 0, 0, 0
with torch.no_grad():
end = time.time()
while True:
# roll out the agent
if self.opts.arch == 'regretful':
loss, traj, categories = self.agent.rollout_regret()
elif self.opts.arch == 'self-monitoring':
loss, traj, categories = self.agent.rollout_monitor()
elif self.opts.arch == 'speaker-baseline':
loss, traj = self.agent.rollout()
else:
raise NotImplementedError()
# Calculate accuracy
acc = []
for gt, predicted in zip(categories[0], categories[1]):
max_index = predicted.max(dim=1)[1]
acc.append(((max_index == gt).sum().item()) /
(max_index.size()[0]))
acc = np.mean(acc) * 100
dist_from_goal = np.mean(self.agent.dist_from_goal)
movement = np.mean(self.agent.traj_length)
accuracy.update(acc, self.opts.batch_size)
losses.update(loss.item(), self.opts.batch_size)
dists.update(dist_from_goal, self.opts.batch_size)
movements.update(movement, self.opts.batch_size)
if self.agent.value_loss is not None:
val_losses.update(self.agent.value_loss.item(),
self.opts.batch_size)
if self.agent.val_acc is not None:
val_acces.update(np.mean(self.agent.val_acc),
self.opts.batch_size)
if self.agent.aux_loss is not None:
aux_losses.update(self.agent.aux_loss.item(),
self.opts.batch_size)
if tb_logger and iter % 10 == 0:
current_iter = iter + (epoch - 1) * val_iters_epoch
tb_logger.add_scalar('{}/loss'.format(env_name), loss,
current_iter)
tb_logger.add_scalar('{}/dist_from_goal'.format(env_name),
dist_from_goal, current_iter)
tb_logger.add_scalar('{}/movements'.format(env_name),
movement, current_iter)
tb_logger.add_scalar('{}/aux_acc'.format(env_name), acc,
current_iter)
if self.agent.value_loss is not None:
tb_logger.add_scalar('{}/val_loss'.format(env_name),
self.agent.value_loss,
current_iter)
success_count, rollback_success_count, rollback_count, oscillating_success_count, oscillating_count = \
count_rollback_success(success_count, rollback_success_count, rollback_count, oscillating_success_count, oscillating_count, traj)
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if self.agent.rollback_attn is not None:
if iter == 1:
rollback_attn = self.agent.rollback_attn
else:
rollback_attn = np.concatenate(
(rollback_attn, self.agent.rollback_attn), axis=1)
print('Epoch: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'.format(
epoch,
iter,
val_iters_epoch,
batch_time=batch_time,
loss=losses))
# write into results
for traj_ in traj:
if traj_['instr_id'] in self.agent.results:
looped = True
else:
result = {
'path': traj_['path'],
'distance': traj_['distance'],
'img_attn': traj_['img_attn'],
'ctx_attn': traj_['ctx_attn'],
'rollback_forward_attn':
traj_['rollback_forward_attn'],
'value': traj_['value'],
'viewpoint_idx': traj_['viewpoint_idx'],
'navigable_idx': traj_['navigable_idx']
}
self.agent.results[traj_['instr_id']] = result
if looped:
break
iter += 1
print('============================')
print('success rate: {}'.format(success_count / len(env.data)))
print('rollback rate: {}'.format(rollback_count / len(env.data)))
print('rollback success rate: {}'.format(rollback_success_count /
len(env.data)))
print('oscillating rate: {}'.format(oscillating_count / len(env.data)))
print('oscillating success rate: {}'.format(oscillating_success_count /
len(env.data)))
print('============================')
if tb_logger:
tb_logger.add_scalar('epoch/{}/loss'.format(env_name), losses.avg,
epoch)
tb_logger.add_scalar('epoch/{}/dist_from_goal'.format(env_name),
dists.avg, epoch)
tb_logger.add_scalar('epoch/{}/movements'.format(env_name),
movements.avg, epoch)
tb_logger.add_scalar('epoch/{}/aux_accuracy'.format(env_name),
accuracy.avg, epoch)
if self.agent.value_loss is not None:
tb_logger.add_scalar('epoch/{}/val_loss'.format(env_name),
val_losses.avg, epoch)
if self.agent.val_acc is not None:
tb_logger.add_scalar('epoch/{}/val_acc'.format(env_name),
val_acces.avg, epoch)
if self.agent.rollback_attn is not None:
for step in range(self.opts.max_episode_len):
tb_logger.add_histogram(
'epoch_{}/rollback_attn_{}'.format(env_name, step),
rollback_attn[step], epoch)
if self.agent.aux_loss is not None:
tb_logger.add_scalar('epoch/{}/aux_loss'.format(env_name),
aux_losses.avg, epoch)
tb_logger.add_scalar(
'rollback_oscillation/{}/rollback'.format(env_name),
rollback_count / len(env.data), epoch)
tb_logger.add_scalar(
'rollback_oscillation/{}/rollback_SR'.format(env_name),
rollback_success_count / len(env.data), epoch)
tb_logger.add_scalar(
'rollback_oscillation/{}/oscillating'.format(env_name),
oscillating_count / len(env.data), epoch)
tb_logger.add_scalar(
'rollback_oscillation/{}/oscillating_SR'.format(env_name),
oscillating_success_count / len(env.data), epoch)
# dump into JSON file
self.agent.results_path = '{}{}_{}_epoch_{}.json'.format(
self.opts.results_dir, self.opts.exp_name, env_name, epoch)
self.agent.write_results()
score_summary, _ = evaluator.score(self.agent.results_path)
result_str = ''
success_rate = 0.0
for metric, val in score_summary.items():
result_str += '| {}: {} '.format(metric, val)
if metric in ['success_rate']:
success_rate = val
if tb_logger:
tb_logger.add_scalar('score/{}/{}'.format(env_name, metric),
val, epoch)
print(result_str)
return success_rate
def __init__(self,
feature_store,
obj_d_feat=None,
obj_s_feat=None,
batch_size=100,
seed=10,
splits=['train'],
tokenizer=None,
name=None):
if obj_d_feat or obj_s_feat:
self.env = ObjEnvBatch(feature_store=feature_store,
obj_d_feat=obj_d_feat,
obj_s_feat=obj_s_feat,
batch_size=batch_size)
else:
self.env = EnvBatch(feature_store=feature_store,
batch_size=batch_size)
if feature_store:
self.feature_size = self.env.feature_size
self.data = []
if tokenizer:
self.tok = tokenizer
scans = []
for split in splits:
for item in load_datasets([split]):
# Split multiple instructions into separate entries
for j, instr in enumerate(item['instructions']):
if item['scan'] not in self.env.featurized_scans: # For fast training
continue
new_item = dict(item)
new_item['instr_id'] = '%s_%d' % (item['path_id'], j)
new_item['instructions'] = instr
if tokenizer:
new_item['instr_encoding'] = tokenizer.encode_sentence(
instr)
if not tokenizer or new_item[
'instr_encoding'] is not None: # Filter the wrong data
self.data.append(new_item)
scans.append(item['scan'])
if name is None:
self.name = splits[0] if len(splits) > 0 else "FAKE"
else:
self.name = name
self.scans = set(scans)
self.splits = splits
self.seed = seed
random.seed(self.seed)
random.shuffle(self.data)
self.ix = 0
self.batch_size = batch_size
self._load_nav_graphs()
self.angle_feature = utils.get_all_point_angle_feature()
self.angle_avg_feature = utils.get_avg_point_angle_feature()
self.sim = utils.new_simulator()
self.buffered_state_dict = {}
# It means that the fake data is equals to data in the supervised setup
self.fake_data = self.data
print('R2RBatch loaded with %d instructions, using splits: %s' %
(len(self.data), ",".join(splits)))
5,
'n_runs':
3,
'rnd_seed':
0,
'n_jobs':
-1
}
if __name__ == '__main__':
# Extract paths
data_path, results_path, _ = generate_paths()
# Load lucas dataset
datasets = load_datasets(data_path=data_path, data_type='csv')
# Extract oversamplers
oversamplers = CONFIG['oversamplers']
# Generate oversamplers
for oversampler in oversamplers:
# Define and fit experiment
experiment = ImbalancedExperiment(
oversamplers=[oversampler],
classifiers=CONFIG['classifiers'],
scoring=CONFIG['scoring'],
n_splits=CONFIG['n_splits'],
n_runs=CONFIG['n_runs'],
random_state=CONFIG['rnd_seed'],
def __init__(self,
feature_store,
candidate_store,
batch_size=100,
seed=10,
splits=['train'],
tokenizer=None,
name=None):
self.env = EnvBatch(feature_store=feature_store,
candidate_store=candidate_store,
batch_size=batch_size)
if feature_store:
self.feature_size = self.env.feature_size
self.data = []
if tokenizer:
self.tok = tokenizer
scans = []
for split in splits:
for item in load_datasets([split]):
# Split multiple instructions into separate entries
for j, instr in enumerate(item['instructions']):
if item['scan'] not in self.env.featurized_scans: # For fast training
continue
new_item = dict(item)
new_item['instr_id'] = '%s_%d' % (item['path_id'], j)
new_item['instructions'] = instr
if tokenizer:
new_item['instr_encoding'] = tokenizer.encode_sentence(
instr)
if not tokenizer or new_item[
'instr_encoding'] is not None: # Filter the wrong data
self.data.append(new_item)
scans.append(item['scan'])
if name is None:
self.name = splits[0] if len(splits) > 0 else "FAKE"
else:
self.name = name
self.scans = set(scans)
self.splits = splits
self.seed = seed
random.seed(self.seed)
random.shuffle(self.data)
if args.filter != "":
filter_name, percent = args.filter.split("_")
percent = int(percent) / 100
scan_list = list(self.scans)
scan_list = sorted(scan_list)
scan_num = len(scan_list)
scan_num_in_use = int(scan_num * percent)
scan_in_use = set(scan_list[:scan_num_in_use])
data_in_use = [
datum for datum in self.data if datum['scan'] in scan_in_use
]
data_num_in_use = len(data_in_use)
if self.name == 'train':
if filter_name == 'env':
print("With the top %d scans and %d data" %
(scan_num_in_use, data_num_in_use))
print("With percent %0.4f and %0.4f" %
(scan_num_in_use / len(self.scans),
data_num_in_use / len(self.data)))
print(scan_in_use)
self.scans = scan_in_use
self.data = data_in_use
assert len(self.data) == data_num_in_use
elif filter_name == 'data':
print("With the all %d scans and %d data" %
(len(self.scans), data_num_in_use))
self.data = self.data[:data_num_in_use]
for datum in self.data[:5]:
print(datum['instr_id'])
assert len(self.data) == data_num_in_use
# elif self.name == 'aug':
# if filter_name == 'env':
# print("With the top %d scans and %d data" % (scan_num_in_use, data_num_in_use))
# print("With percent %0.4f and %0.4f" % (scan_num_in_use / len(self.scans), data_num_in_use / len(self.data)))
# print(scan_in_use)
# self.scans = scan_in_use
# self.data = data_in_use
# assert len(self.data) == data_num_in_use
# elif filter_name == 'data':
# print("With the all %d scans and %d data" % (len(self.scans), len(self.data)))
self.ix = 0
self.batch_size = batch_size
self._load_nav_graphs()
self.angle_feature = utils.get_all_point_angle_feature()
self.sim = utils.new_simulator()
self.buffered_state_dict = {}
# It means that the fake data is equals to data in the supervised setup
self.fake_data = self.data
print('R2RBatch loaded with %d instructions, using splits: %s' %
(len(self.data), ",".join(splits)))
def eval(self, epoch, val_env, tb_logger=None):
batch_time = AverageMeter()
losses = AverageMeter()
dists = AverageMeter()
movements = AverageMeter()
val_losses = AverageMeter()
val_acces = AverageMeter()
env_name, (env, evaluator) = val_env
print('Evaluating on {} env ...'.format(env_name))
self.agent.env = env
self.agent.env.reset_epoch()
self.agent.model.eval()
self.agent.encoder.eval()
self.agent.feedback = self.opts.feedback
self.agent.value_loss = None
self.agent.val_acc = None
# load dataset path for computing ground truth distance
self.agent.gt = {}
for item in load_datasets([env_name]):
self.agent.gt[item['path_id']] = item
val_iters_epoch = math.ceil(len(env.data) / self.opts.batch_size)
self.agent.results = {}
looped = False
iter = 1
with torch.no_grad():
end = time.time()
while True:
if self.opts.progress_inference:
traj = self.agent.sample_progress_inference(
self.opts.beam_size)
elif self.opts.eval_beam:
traj = self.agent.sample_beam(self.opts.beam_size)
else:
# rollout the agent
if self.opts.arch == 'self-monitoring':
loss, traj = self.agent.rollout_monitor()
elif self.opts.arch == 'speaker-baseline':
loss, traj = self.agent.rollout()
else:
raise NotImplementedError()
dist_from_goal = np.mean(self.agent.dist_from_goal)
movement = np.mean(self.agent.traj_length)
losses.update(loss.item(), self.opts.batch_size)
dists.update(dist_from_goal, self.opts.batch_size)
movements.update(movement, self.opts.batch_size)
if self.agent.value_loss is not None:
val_losses.update(self.agent.value_loss.item(),
self.opts.batch_size)
if self.agent.val_acc is not None:
val_acces.update(np.mean(self.agent.val_acc),
self.opts.batch_size)
if tb_logger and iter % 10 == 0:
current_iter = iter + (epoch - 1) * val_iters_epoch
tb_logger.add_scalar('{}/loss'.format(env_name), loss,
current_iter)
tb_logger.add_scalar(
'{}/dist_from_goal'.format(env_name),
dist_from_goal, current_iter)
tb_logger.add_scalar('{}/movements'.format(env_name),
movement, current_iter)
if self.agent.value_loss is not None:
tb_logger.add_scalar(
'{}/val_loss'.format(env_name),
self.agent.value_loss, current_iter)
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
print('Epoch: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'.format(
epoch,
iter,
val_iters_epoch,
batch_time=batch_time,
loss=losses))
# write into results
for traj_ in traj:
if traj_['instr_id'] in self.agent.results:
looped = True
else:
result = {
'path': traj_['path'],
'distance': traj_['distance'],
'img_attn': traj_['img_attn'],
'ctx_attn': traj_['ctx_attn'],
'value': traj_['value'],
'viewpoint_idx': traj_['viewpoint_idx'],
'navigable_idx': traj_['navigable_idx']
}
self.agent.results[traj_['instr_id']] = result
if looped:
break
iter += 1
if tb_logger:
tb_logger.add_scalar('epoch/{}/loss'.format(env_name), losses.avg,
epoch)
tb_logger.add_scalar('epoch/{}/dist_from_goal'.format(env_name),
dists.avg, epoch)
tb_logger.add_scalar('epoch/{}/movements'.format(env_name),
movements.avg, epoch)
if self.agent.value_loss is not None:
tb_logger.add_scalar('epoch/{}/val_loss'.format(env_name),
val_losses.avg, epoch)
if self.agent.val_acc is not None:
tb_logger.add_scalar('epoch/{}/val_acc'.format(env_name),
val_acces.avg, epoch)
# dump into JSON file
if self.opts.eval_beam:
self.agent.results_path = '{}{}-beam_{}_{}_epoch_{}.json'.format(
self.opts.results_dir, self.opts.exp_name, self.opts.beam_size,
env_name, epoch)
else:
self.agent.results_path = '{}{}_{}_epoch_{}.json'.format(
self.opts.results_dir, self.opts.exp_name, env_name, epoch)
self.agent.write_results()
score_summary, _ = evaluator.score(self.agent.results_path)
result_str = ''
success_rate = 0.0
for metric, val in score_summary.items():
result_str += '| {}: {} '.format(metric, val)
if metric in ['success_rate']:
success_rate = val
if tb_logger:
tb_logger.add_scalar('score/{}/{}'.format(env_name, metric),
val, epoch)
print(result_str)
return success_rate
def main():
# load train and test datasets
train_x, train_y, test_x, test_y = load_datasets()
# load model hyperparams
epochs, batch_size, learning_rate, model_replica_path, dropout_rate = load_hyperparams(
)
# init dropout params
train_dropout_rate = dropout_rate
test_dropout_rate = 0.0
# remove previous weights, bias, inputs, etc..
tf.reset_default_graph()
# init inputs
x = tf.placeholder(tf.float32, shape=(None, 32, 32, 3), name='x')
y = tf.placeholder(tf.float32, shape=(None, 10), name='y')
dropout_rate = tf.placeholder(tf.float32, name='dropout_rate')
# init layer biases and weights
weights, biases = get_layer_weights(), get_layer_biases()
# init model
model = net(x, biases=biases, weights=weights, dropout_rate=dropout_rate)
# init optimization function
cost = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits_v2(logits=model, labels=y))
optimizer = tf.train.AdamOptimizer(
learning_rate=learning_rate).minimize(cost)
# accuracy function
correct_prediction = tf.equal(tf.argmax(model, 1), tf.argmax(y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# create tensorflow session
with tf.Session() as session:
session.run(tf.global_variables_initializer())
train_loss, test_loss, train_accuracy, test_accuracy = [], [], [], []
summary_writer = tf.summary.FileWriter('./output', session.graph)
print('Training')
for i in range(epochs):
print('Epoch {} :'.format(i + 1))
for batch in range(len(train_x) // batch_size):
batch_x = train_x[batch *
batch_size:min((batch + 1) *
batch_size, len(train_x))]
batch_y = train_y[batch *
batch_size:min((batch + 1) *
batch_size, len(train_y))]
# start training
session.run(optimizer,
feed_dict={
x: batch_x,
y: batch_y,
dropout_rate: train_dropout_rate
})
# compute metrics
train_loss_batch, train_accuracy_batch = session.run(
[cost, accuracy],
feed_dict={
x: batch_x,
y: batch_y,
dropout_rate: train_dropout_rate
})
print('Batch range:{} - {} Loss: {:>10.4f} Accuracy: {:.6f}'.
format(batch * batch_size,
min((batch + 1) * batch_size, len(train_x)),
train_loss_batch, train_accuracy_batch))
test_accuracy_batch, test_loss_batch = session.run(
[accuracy, cost],
feed_dict={
x: test_x,
y: test_y,
dropout_rate: test_dropout_rate
})
print(
'Epoch {} finished, Loss: {:>10.4f} Validation Accuracy: {:.6f}'
.format((i + 1), test_loss_batch, test_accuracy_batch))
train_loss.append(train_loss_batch)
test_loss.append(test_loss_batch)
train_accuracy.append(train_accuracy_batch)
test_accuracy.append(test_accuracy_batch)
save_model(session, model_replica_path)
# draw plots
loss_plot(train_loss, test_loss)
accuracy_plot(train_accuracy, test_accuracy)
summary_writer.close()
parser = argparse.ArgumentParser()
parser.add_argument('--config', default='./configs/default.json')
options = parser.parse_args()
config = json.load(open(options.config))
now = datetime.datetime.now()
filename = 'log_lgbm_{0:%Y%m%d%H%M%S}.log'.format(now)
logging.basicConfig(filename='./logs/' + filename, level=logging.DEBUG)
logging.debug('./logs/' + filename)
feats = config['features']
logging.debug(feats)
target_name = config['target_name']
X_train_all, X_test = load_datasets(feats)
y_train_all = load_target(target_name)
logging.debug(X_train_all.shape)
# old_oof = pd.read_feather("./features/lgbm_train.feather")
# drop_idx = np.where((old_oof.lgbm_pred.values >= 0.1) & (old_oof.lgbm_pred.values < 0.13))[0]
# print("=== remove several rows===")
# logging.debug("=== remove several rows===")
# X_train_all, y_train_all = remove_row(X_train_all, y_train_all, drop_idx)
print(X_train_all.shape)
y_preds = []
models = []
oof = np.zeros(len(X_train_all))
def __init__(self, feature_store, nav_graphs, panoramic, action_space, beam_size=1, batch_size=100, seed=10, splits=['train'], tokenizer=None, path_type=None, history=None, blind=False): # , subgoal
self.env = EnvBatch(feature_store=feature_store, batch_size=batch_size, beam_size=beam_size,blind=blind)
self.data = []
self.scans = []
self.panoramic = panoramic
self.nav_graphs= nav_graphs
self.action_space = action_space
self.ctrl_feature = None
if tokenizer:
tokname = tokenizer.__class__.__name__
longest_inst = list()
longest_ep_len = list()
for item in load_datasets(splits):
# For every dialog history, stitch together a single instruction string.
self.scans.append(item['scan'])
new_item = dict(item)
new_item['inst_idx'] = item['inst_idx']
if history == 'none': # no language input at all
new_item['instructions'] = ''
if tokenizer:
new_item['instr_encoding'] = tokenizer.encode_sentence('')
elif history == 'target' or len(item['dialog_history']) == 0: # Have to use target only if no dialog history.
tar = item['target']
new_item['instructions'] = '<TAR> ' + tar
if tokenizer:
if tokname == 'Tokenizer':
new_item['instr_encoding'] = tokenizer.encode_sentence([tar], seps=['<TAR>'])
else:
new_item['instr_encoding'] = tokenizer.encode_sentence(tar)
elif history == 'oracle_ans':
ora_a = item['dialog_history'][-1]['message'] # i.e., the last oracle utterance.
tar = item['target']
new_item['instructions'] = '<ORA> ' + ora_a + ' <TAR> ' + tar
if tokenizer:
if tokname == 'Tokenizer':
new_item['instr_encoding'] = tokenizer.encode_sentence([ora_a, tar], seps=['<ORA>', '<TAR>'])
else:
new_item['instr_encoding'] = tokenizer.encode_sentence(new_item['instructions'])
elif history == 'nav_q_oracle_ans':
nav_q = item['dialog_history'][-2]['message']
ora_a = item['dialog_history'][-1]['message']
tar = item['target']
new_item['instructions'] = '<NAV> ' + nav_q + ' <ORA> ' + ora_a + ' <TAR> ' + tar
if tokenizer:
if tokname == 'Tokenizer':
qa_enc = tokenizer.encode_sentence([nav_q, ora_a, tar], seps=['<NAV>', '<ORA>', '<TAR>'])
else:
qa_enc = tokenizer.encode_sentence(new_item['instructions'])
new_item['instr_encoding'] = qa_enc
elif history == 'all':
dia_inst = ''
sentences = []
seps = []
for turn in item['dialog_history']:
sentences.append(turn['message'])
sep = '<NAV>' if turn['role'] == 'navigator' else '<ORA>'
seps.append(sep)
dia_inst += sep + ' ' + turn['message'] + ' '
sentences.append(item['target'])
seps.append('<TAR>')
dia_inst += '<TAR> ' + item['target']
new_item['instructions'] = dia_inst
if tokenizer:
if tokname == "Tokenizer":
dia_enc = tokenizer.encode_sentence(sentences, seps=seps)
else:
dia_enc = tokenizer.encode_sentence(dia_inst)
new_item['instr_encoding'] = dia_enc
# If evaluating against 'trusted_path', we need to calculate the trusted path and instantiate it.
if path_type == 'trusted_path':
# The trusted path is either the planner_path or the player_path depending on whether the player_path
# contains the planner_path goal (e.g., stricter planner oracle success of player_path
# indicates we can 'trust' it, otherwise we fall back to the planner path for supervision).
# Hypothesize that this will combine the strengths of good human exploration with the known good, if
# short, routes the planner uses.
planner_goal = item['planner_path'][-1] # this could be length 1 if "plan" is to not move at all.
if planner_goal in item['player_path'][1:]: # player walked through planner goal (did not start on it)
new_item['trusted_path'] = item['player_path'][:] # trust the player.
else:
new_item['trusted_path'] = item['planner_path'][:] # trust the planner.
longest_ep_len.append(len(new_item[path_type]))
longest_inst.append(len(new_item['instructions'].split()))
self.data.append(new_item)
self.scans = set(self.scans)
self.splits = splits
if seed!= 'resume':
self.seed = seed
random.seed(self.seed)
random.shuffle(self.data)
self.ix = 0
self.batch_size = batch_size
self._load_nav_graphs()
self.epo_inc = False # jolin: middle of an epoch
self.path_type = path_type
#self.env.pre_loadSims(self.data) # debug
print('R2RBatch loaded with %d instructions, using splits: %s' % (len(self.data), ",".join(splits)))
print('Instructions avg length %d, max length %d, using splits: %s' % (np.mean(longest_inst),np.max(longest_inst), ",".join(splits)))
print('Path avg length %d, max length %d, using splits: %s' % (np.mean(longest_ep_len),np.max(longest_ep_len), ",".join(splits)))
parser = argparse.ArgumentParser()
parser.add_argument('--config', default='./configs/default_v02.json')
options = parser.parse_args()
config = json.load(open(options.config))
now = datetime.datetime.now()
logging.basicConfig(filename='./logs/log_{0:%Y%m%d%H%M%S}.log'.format(now),
level=logging.DEBUG)
logging.debug('./logs/log_{0:%Y%m%d%H%M%S}.log'.format(now))
feats = config['features']
logging.debug(feats)
target_name = config['target_name']
X_train_all, X_test = load_datasets(feats, target_name)
y_train_all = load_target(target_name)
logging.debug(X_train_all.shape)
y_preds = []
models = []
lgbm_params = config['lgbm_params']
kf = KFold(n_splits=10, random_state=0)
for train_index, valid_index in kf.split(X_train_all):
X_train, X_valid = (X_train_all.iloc[train_index, :],
X_train_all.iloc[valid_index, :])
y_train, y_valid = y_train_all[train_index], y_train_all[valid_index]
# lgbmの実行
def __init__(self,
feature_store,
pano_caffee=None,
batch_size=100,
seed=10,
splits=['train'],
tokenizer=None,
name=None):
self.env = EnvBatch(feature_store=feature_store, batch_size=batch_size)
if feature_store:
self.feature_size = self.env.feature_size
self.data = []
self.configs = {}
self.motion_indicator = {}
self.landmark = {}
if not name:
configs = np.load(args.configpath + "configs_" + splits[0] +
".npy",
allow_pickle=True).item()
self.configs.update(configs)
if tokenizer:
self.tok = tokenizer
scans = []
for item in tqdm(load_datasets(splits)):
# Split multiple instructions into separate entries
for j, instr in enumerate(item['instructions']):
if item['scan'] not in self.env.featurized_scans: # For fast training
continue
new_item = dict(item)
new_item['instr_id'] = '%s_%d' % (item['path_id'], j)
#new_item['instr_id'] = str(item['path_id'])
if args.configuration and not name:
each_configuration_list = self.configs[str(
new_item['instr_id'])]
# each_configuration_list = get_configurations(instr)
# self.configs[str(new_item['instr_id'])] = each_configuration_list
for config_id, each_c in enumerate(
each_configuration_list):
#self.motion_indicator[str(new_item['instr_id']) + "_" + str(config_id)] = get_motion_indicator(each_c)
self.landmark[str(new_item['instr_id']) + "_" +
str(config_id)] = get_landmark(
each_c, whether_root=True)
new_item['configurations'] = each_configuration_list
configuration_length = len(each_configuration_list)
tmp_str = " Quan ".join(each_configuration_list) + " Quan"
new_item['instructions'] = tmp_str
if configuration_length:
self.data.append(
(len(new_item['configurations']), new_item))
if tokenizer:
if 'instr_encoding' not in item: # we may already include 'instr_encoding' when generating synthetic instructions
new_item[
'instr_encoding'] = tokenizer.encode_sentence(
tmp_str)
else:
new_item['instructions'] = instr
if tokenizer:
new_item['instr_encoding'] = tokenizer.encode_sentence(
instr)
if not tokenizer or new_item[
'instr_encoding'] is not None: # Filter the wrong data
self.data.append(new_item)
scans.append(item['scan'])
np.save(
f"/VL/space/zhan1624/R2R-EnvDrop/r2r_src/components3/landmarks/landmark_{splits[0]}.npy",
self.landmark)
'''
np.save(f"/VL/space/zhan1624/R2R-EnvDrop/r2r_src/components2/configs/configs_{splits[0]}.npy", self.configs)
np.save(f"/VL/space/zhan1624/R2R-EnvDrop/r2r_src/components2/motion_indicator/motion_indicator_{splits[0]}.npy", self.motion_indicator)
np.save(f"/VL/space/zhan1624/R2R-EnvDrop/r2r_src/components2/landmarks/landmark_{splits[0]}.npy", self.landmark)
'''
if name is None:
self.name = splits[0] if len(splits) > 0 else "FAKE"
else:
self.name = name
self.pano_caffee = pano_caffee
self.scans = set(scans)
self.splits = splits
if args.configuration and not name:
# self.data.sort(key=lambda x: x[0])
self.data = list(map(lambda item: item[1], self.data))
self.seed = seed
random.seed(self.seed)
random.shuffle(self.data)
self.ix = 0
self.batch_size = batch_size
self._load_nav_graphs()
self.angle_feature, self.pano_angles = list(
zip(*utils.get_all_point_angle_feature()))
self.sim = utils.new_simulator()
self.buffered_state_dict = {}
# It means that the fake data is equals to data in the supervised setup
self.fake_data = self.data
print('R2RBatch loaded with %d instructions, using splits: %s' %
(len(self.data), ",".join(splits)))
def benchmark_trvae(dataset, log_name, cfg, **kwargs):
ds = dataset
n_genes = min(ds.X.shape[1], cfg.n_genes)
scvai_genes, scvai_batches_ind, scvai_labels_ind = get_high_variance_genes(
ds.X,
ds.batch_indices,
ds.labels,
n_genes = n_genes,
argmax=False
)
cfg.count_classes = int(np.max(ds.batch_indices) + 1)
cfg.count_labels = int(np.max(ds.labels) + 1)
cfg.input_dim = int(scvai_genes.shape[1])
data = load_datasets(cfg, True, True,
(scvai_genes, scvai_batches_ind, scvai_labels_ind),
0.9)
dataloader_train = data[0]
dataloader_val = data[1]
dataloader_test = data[2]
annot_train = data[3]
annot_test = data[4]
x, batch_ind, celltype = annot_train.dataset.tensors
batch_ind = batch_ind.argmax(dim=1)
celltype = celltype.argmax(dim=1)
anndata_train = make_anndata(x.cpu().numpy(),
batch_ind.cpu().numpy(),
'condition',
celltype.cpu().numpy(),
'cell_type')
x_test, batch_ind_test, celltype_test = annot_test.dataset.tensors
batch_ind_test = batch_ind_test.argmax(dim=1)
celltype_test = celltype_test.argmax(dim=1)
anndata_test = make_anndata(x_test.cpu().numpy(), batch_ind_test.cpu().numpy(),
'condition', celltype_test.cpu().numpy(), 'cell_type')
sc.pp.normalize_per_cell(anndata_train)
sc.pp.normalize_per_cell(anndata_test)
sc.pp.log1p(anndata_train)
sc.pp.log1p(anndata_test)
n_conditions = anndata_train.obs["condition"].unique().shape[0]
x_test = anndata_test.X
batch_ind_test_tmp = anndata_test.obs['condition']
batch_ind_test = zeros(batch_ind_test_tmp.shape[0], cfg.count_classes)
batch_ind_test = batch_ind_test.scatter(1, LongTensor(batch_ind_test_tmp.astype('uint16')).view(-1, 1), 1).numpy()
celltype_test_tmp = anndata_test.obs['cell_type']
celltype_test = zeros(celltype_test_tmp.shape[0], cfg.count_labels)
celltype_test = celltype_test.scatter(1, LongTensor(celltype_test_tmp.astype('uint16')).view(-1, 1), 1).numpy()
model = trVAE(x.shape[1],
num_classes=n_conditions,
encoder_layer_sizes=[128, 32],
decoder_layer_sizes=[32, 128],
latent_dim=cfg.bottleneck,
alpha=0.0001,
)
trainer = trvaep.Trainer(model, anndata_train)
print('Training...')
trainer.train_trvae(cfg.epochs, 512, 50)#n_epochs, batch_size, early_patience
print('Tests...')
print('Dataset:', log_name)
res = test(cfg,
model, None,
annot_train,
x_test,
batch_ind_test,
celltype_test
)
res['n_genes'] = n_genes
metrics_path = Path(cfg.metrics_dir) / 'trVAE'
metrics_path.mkdir(parents=True, exist_ok=True)
with open(metrics_path / (log_name + '.json'), 'w') as file:
json.dump(res, file, indent=4)
del ds
del model
del data
del dataloader_train, dataloader_val, dataloader_test
del annot_train, annot_test
del scvai_genes, scvai_batches_ind, scvai_labels_ind
cuda.empty_cache()
def __init__(self,
feature_store,
batch_size=100,
seed=10,
splits=['train'],
tokenizer=None,
path_type='planner_path',
history='target',
blind=False):
self.env = EnvBatch(feature_store=feature_store,
batch_size=batch_size,
blind=blind)
self.data = []
self.scans = []
for item in load_datasets(splits):
# For every dialog history, stitch together a single instruction string.
self.scans.append(item['scan'])
new_item = dict(item)
new_item['inst_idx'] = item['inst_idx']
if history == 'none': # no language input at all
new_item['instructions'] = ''
if tokenizer:
new_item['instr_encoding'] = tokenizer.encode_sentence('')
elif history == 'target' or len(
item['dialog_history']
) == 0: # Have to use target only if no dialog history.
tar = item['target']
new_item['instructions'] = '<TAR> ' + tar
if tokenizer:
new_item['instr_encoding'] = tokenizer.encode_sentence(
[tar], seps=['<TAR>'])
elif history == 'oracle_ans':
ora_a = item['dialog_history'][-1][
'message'] # i.e., the last oracle utterance.
tar = item['target']
new_item['instructions'] = '<ORA> ' + ora_a + ' <TAR> ' + tar
if tokenizer:
new_item['instr_encoding'] = tokenizer.encode_sentence(
[ora_a, tar], seps=['<ORA>', '<TAR>'])
elif history == 'nav_q_oracle_ans':
nav_q = item['dialog_history'][-2]['message']
ora_a = item['dialog_history'][-1]['message']
tar = item['target']
new_item[
'instructions'] = '<NAV> ' + nav_q + ' <ORA> ' + ora_a + ' <TAR> ' + tar
if tokenizer:
qa_enc = tokenizer.encode_sentence(
[nav_q, ora_a, tar], seps=['<NAV>', '<ORA>', '<TAR>'])
new_item['instr_encoding'] = qa_enc
elif history == 'all':
dia_inst = ''
sentences = []
seps = []
for turn in item['dialog_history']:
sentences.append(turn['message'])
sep = '<NAV>' if turn['role'] == 'navigator' else '<ORA>'
seps.append(sep)
dia_inst += sep + ' ' + turn['message'] + ' '
sentences.append(item['target'])
seps.append('<TAR>')
dia_inst += '<TAR> ' + item['target']
new_item['instructions'] = dia_inst
if tokenizer:
dia_enc = tokenizer.encode_sentence(sentences, seps=seps)
new_item['instr_encoding'] = dia_enc
# If evaluating against 'trusted_path', we need to calculate the trusted path and instantiate it.
if path_type == 'trusted_path':
# The trusted path is either the planner_path or the player_path depending on whether the player_path
# contains the planner_path goal (e.g., stricter planner oracle success of player_path
# indicates we can 'trust' it, otherwise we fall back to the planner path for supervision).
# Hypothesize that this will combine the strengths of good human exploration with the known good, if
# short, routes the planner uses.
planner_goal = item['planner_path'][
-1] # this could be length 1 if "plan" is to not move at all.
if planner_goal in item['player_path'][
1:]: # player walked through planner goal (did not start on it)
new_item['trusted_path'] = item[
'player_path'][:] # trust the player.
else:
new_item['trusted_path'] = item[
'planner_path'][:] # trust the planner.
self.data.append(new_item)
self.scans = set(self.scans)
self.splits = splits
self.seed = seed
random.seed(self.seed)
random.shuffle(self.data)
self.ix = 0
self.batch_size = batch_size
self._load_nav_graphs()
self.path_type = path_type
print 'R2RBatch loaded with %d instructions, using splits: %s' % (len(
self.data), ",".join(splits))
