def main():
args = parse_args()
if "trial_id" not in args:
print('Need Model Trial ID')
exit()
num_gpus = int(
os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1
args.distributed = num_gpus > 1
if not args.no_cuda and torch.cuda.is_available():
cudnn.benchmark = True
args.device = "cuda"
else:
args.distributed = False
args.device = "cpu"
args.save_pred = True
if args.save_pred:
outdir = 'runs/{}_{}'.format(args.model, args.trial_id)
args.out_dir = outdir
if not os.path.exists(outdir):
os.makedirs(outdir)
logger = setup_logger("affordance_prediction",
args.log_dir,
get_rank(),
filename='{}_{}_eval_log.txt'.format(
args.model, args.trial_id))
args.logger = logger
run_eval(args)
def test_default_arguments_1(self):
''' train.py:parse_args: check that default arguments match expectations '''
arglist = parse_args("")
self.assertTrue(arglist.environment == "MultiAgentEnv")
self.assertTrue(arglist.scenario == "simple")
self.assertTrue(arglist.max_episode_len == 50)
self.assertTrue(arglist.num_episodes == 60000)
self.assertTrue(arglist.num_adversaries == 0)
self.assertTrue(arglist.good_policy == "maddpg")
self.assertTrue(arglist.adv_policy == "maddpg")
self.assertTrue(arglist.variable_num_agents == 4)
self.assertTrue(arglist.variable_num_hazards == 0)
self.assertTrue(arglist.variable_local_rewards == False)
self.assertTrue(arglist.variable_observation_type == "direct")
self.assertTrue(arglist.training_algorithm == "MADDPGAgentTrainer")
self.assertTrue(arglist.learning_rate == 1e-2)
self.assertTrue(arglist.variable_learning_rate == False)
self.assertTrue(arglist.learning_rate_min == 1e-5)
self.assertTrue(arglist.learning_rate_period == 10)
self.assertTrue(arglist.entropy_coef == 0.0)
self.assertTrue(arglist.value_coef == 0.5)
self.assertTrue(arglist.gamma == 0.95)
self.assertTrue(arglist.batch_size == 1024)
self.assertTrue(arglist.num_layers == 2)
self.assertTrue(arglist.num_units == 64)
self.assertTrue(arglist.activation == "relu")
self.assertTrue(arglist.cliprange == 0.2)
self.assertTrue(
arglist.critic_type == "distributed_local_observations")
self.assertTrue(arglist.num_minibatches == 4)
self.assertTrue(arglist.num_opt_epochs == 4)
self.assertTrue(arglist.experiment_name == 'default')
self.assertTrue(arglist.save_dir == "./experiments/default/policy/")
self.assertTrue(arglist.save_rate == 1000)
self.assertTrue(arglist.load_dir == "")
def load_agent(ckpt):
game = os.path.basename(ckpt) # checkpoints/Pong-v0.pt -> Pong-v0.pt
game, _ = os.path.splitext(game) # Pong-v0.pt -> Pong-v0
args = parse_args([])
agent = Agent(
game=game,
replay_buffer_capacity=args.replay_buffer_capacity,
# Minimum possible for agent.__init__()
replay_start_size=args.batch_size,
batch_size=args.batch_size,
discount_factor=args.discount_factor,
lr=args.lr,
print_self=False,
)
agent.policy_net.load_state_dict(torch.load(ckpt))
agent.policy_net.eval()
return agent, game
def test_model(model_path, predict_csv_save_name, test_img_save_path):
args = parse_args()
# load test data
dataset_test = Dataset(args.test_csv_path)
test_loader = torch.utils.data.DataLoader(dataset_test)
# load model
# model = Simple_CNN()
# model = LeNet5()
model = Simple_CNN_30()
# resnet = torchvision.models.resnet18(pretrained=True)
# resnet.conv1 = nn.Conv2d(in_channels=1, out_channels=64, kernel_size=7, stride=2, padding=3, bias=False)
# resnet.fc = nn.Linear(in_features=512, out_features=2)
# model = resnet
checkpoint = torch.load(model_path)
model.load_state_dict(checkpoint['net'])
# for save value to csv
out = open(predict_csv_save_name, 'w')
out.writelines("name" + "," + "label" + "," + "predict" + "\n")
# for roc
pos_score_list = []
actual_val_list = []
predict_label_list = []
for num, test_item in enumerate(test_loader):
inputs, actual_val, img_name, img = test_item
predicted_val = model(inputs)
predicted_val = predicted_val.data
max_score, predict_label = torch.max(predicted_val, 1)
# for save_img
# img_split_save(test_img_save_path, img_name, img, actual_val, predict_label)
#save predict to csv
# out.writelines(img_name[0] + "," +str(actual_val.numpy()[0]) + "," + str(predict_label.numpy()[0]) + "\n")
pos_score = predicted_val.numpy()[0][1]
pos_score_list.append(pos_score)
actual_val_list.append(actual_val.numpy()[0])
predict_label_list.append(predict_label.numpy()[0])
# print('label:', actual_val.numpy()[0], 'predict:', predict_label.numpy()[0], max_score.numpy()[0])
gene_roc_curve(actual_val_list, pos_score_list, 1)
# gene_free_roc_curve(actual_val_list, pos_score_list, 1, 163)
gene_recall_and_precison(actual_val_list, predict_label_list, 1)
def train():
tf.logging.set_verbosity(tf.logging.INFO)
args = parse_args()
args.train = TRAIN_TF
args.valid = TEST_TF
args.vocab = VOCAB_TABLE
args.model_dir = MODEL_DIR
vocab_list = utils.load_vocab(args.vocab)
vocab_size = len(vocab_list)
conf = tf.estimator.RunConfig(model_dir=args.model_dir)
hparams = utils.create_hparams(args, vocab_size, utils.SOS_ID,
utils.EOS_ID)
model = tf.estimator.Estimator(model_fn=las_model_fn,
config=conf,
params=hparams)
if args.valid:
train_spec = tf.estimator.TrainSpec(
input_fn=lambda: input_fn(args.train,
args.vocab,
num_channels=args.num_channels,
batch_size=args.batch_size,
num_epochs=args.num_epochs))
eval_spec = tf.estimator.EvalSpec(
input_fn=lambda: input_fn(args.valid or args.train,
args.vocab,
num_channels=args.num_channels,
batch_size=args.batch_size),
start_delay_secs=60,
throttle_secs=args.eval_secs)
tf.estimator.train_and_evaluate(model, train_spec, eval_spec)
else:
model.train(input_fn=lambda: input_fn(args.train,
args.vocab,
num_channels=args.num_channels,
batch_size=args.batch_size,
num_epochs=args.num_epochs))
i + 1, pixAcc * 100, mIoU * 100))
if self.args.save_pred:
pred = torch.argmax(outputs[0], 1)
pred = pred.cpu().data.numpy()
predict = pred.squeeze(0)
mask = get_color_pallete(predict, args.dataset)
mask.save(
os.path.join(outdir,
os.path.splitext(filename[0])[0] + '.png'))
synchronize()
if __name__ == '__main__':
args = parse_args()
num_gpus = int(
os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1
args.distributed = num_gpus > 1
if not args.no_cuda and torch.cuda.is_available():
cudnn.benchmark = True
args.device = "cuda"
else:
args.distributed = False
args.device = "cpu"
if args.distributed:
torch.cuda.set_device(args.local_rank)
torch.distributed.init_process_group(backend="nccl",
init_method="env://")
synchronize()
mfile.write(model)
mfile.close()
#get hyperparamters
base_lr = 10**params.base_lr_exp
momentum = params.momentum
weight_decay = 10**params.weight_decay_exp
solver = params.solver
#setup training
prefix = '%s%d_' % (args.prefix, args.split)
trainargs = train.parse_args([
'--seed',
str(args.seed), '--prefix', prefix, '--data_root', args.data_root, '-t',
'1000', '-i', '250000', '-m', 'model.model', '--checkpoint', '--reduced',
'-o', d, '--momentum',
str(momentum), '--weight_decay',
str(weight_decay), '--base_lr',
str(base_lr), '--solver', solver, '--dynamic', '--lr_policy', 'fixed'
])[0]
train_test_files = train.get_train_test_files(prefix=prefix,
foldnums=None,
allfolds=False,
reduced=True,
prefix2=None)
if len(train_test_files) == 0:
print("error: missing train/test files", prefix)
sys.exit(1)
outprefix = d
print("Number of episodes where each agent occupies exactly one landmark:", np.sum(idx))
print("Agent1 covered counts by landmark:", np.sum(y1[idx], axis=0))
print("Agent2 covered counts by landmark:", np.sum(y2[idx], axis=0))
print("Agent3 covered counts by landmark:", np.sum(y3[idx], axis=0))
print()
# divide sum of collisions by 2, because every collision is counted twice
# sum collisions per episode and take mean over episodes
print("Mean number of collisions per episode:", np.mean(np.sum((collisions1 + collisions2 + collisions3) / 2, axis=-1)))
print("Average agent distance from the closest landmark at the end:",
np.mean(np.min(np.stack([landmarks1, landmarks2, landmarks3]), axis=-1)))
print()
if args.policy_file and args.output_file:
strargs = ['--benchmark', '--deterministic'] + unknown_args
arglist = parse_args(strargs)
#tf.reset_default_graph()
#tf.InteractiveSession().as_default()
with tf.Session().as_default():
# Create environment
env = make_env('simple_spread', arglist, arglist.benchmark)
# Create agent trainers
obs_shape_n = [env.observation_space[i].shape for i in range(env.n)]
num_adversaries = min(env.n, arglist.num_adversaries)
trainers = get_trainers(env, num_adversaries, obs_shape_n, arglist)
#print('Using good policy {} and adv policy {}'.format(arglist.good_policy, arglist.adv_policy))
# Initialize
U.initialize()
res = train.main(config, return_results=True)
tacc.append(
res["target"]["accuracy"],
)
sacc.append(
res["sensitive"]["accuracy"],
)
return {"target_acc": tacc, "sens_acc": sacc}
if __name__ == "__main__":
seeds = [1, 2, 3]
df = pd.DataFrame(columns=["target_acc", "sens_acc"])
args = train.parse_args()
if args.dataset not in ["cifar10", "cifar100"]:
raise ValueError(
"Only cifar10 and cifar100 can be ran with this script"
)
config = utils.Config(args)
config.dataset = "cifar10"
df.loc["cifar10"] = run(config)
df.to_pickle(RESULTS_DIR / f"cifar_results")
print(df)
config.dataset = "cifar100"
df.loc["cifar100"] = run(config)
from data import create_data
from svhn_dataset import SVHN
from train import RetinaTrainer, parse_args, output_predictions
import efficientdet
import utils
from coco_eval import CocoEvaluation
if __name__ == '__main__':
args, argstr = parse_args(skip_name = True)
# Prepare data
num_classes = SVHN.LABELS
pyramid_levels = args.pyramid_levels
anchors = utils.generate_anchors(pyramid_levels, args.image_size,
num_scales=args.num_scales, aspect_ratios=args.aspect_ratios)
train_dataset, dev_dataset, _ = create_data(args.batch_size,
anchors, image_size = args.image_size,
test=args.test, augmentation=args.augmentation)
# Prepare network and trainer
anchors_per_level = args.num_scales * len(args.aspect_ratios)
network = efficientdet.EfficientDet(num_classes, anchors_per_level,
input_size = args.image_size, pyramid_levels = pyramid_levels,
filters=args.efficientdet_filters, num_layers = args.efficientdet_layers)
model = RetinaTrainer(network, anchors, train_dataset, dev_dataset, args)
# Load weights
model.model.load_weights('model.h5')
def main():
config = parse_args()
run_test(config)
os.chdir(d)
mfile = open('model.model','w')
mfile.write(model)
mfile.close()
#get hyperparamters
base_lr = 10**params.base_lr_exp
momentum=params.momentum
weight_decay = 10**params.weight_decay_exp
solver = params.solver
#setup training
prefix = '%s%d_'% (args.prefix,args.split)
trainargs = train.parse_args(['--seed',str(args.seed),'--prefix',prefix,'--data_root',
args.data_root,'-t','1000','-i','250000','-m','model.model','--checkpoint',
'--reduced','-o',d,'--momentum',str(momentum),'--weight_decay',str(weight_decay),
'--base_lr',str(base_lr),'--solver',solver,'--dynamic','--lr_policy','fixed'])[0]
train_test_files = train.get_train_test_files(prefix=prefix, foldnums=None, allfolds=False, reduced=True, prefix2=None)
if len(train_test_files) == 0:
print "error: missing train/test files",prefix
sys.exit(1)
outprefix = d
#train
numfolds = 0
for i in train_test_files:
outname = '%s.%s' % (outprefix, i)
results = train.train_and_test_model(trainargs, train_test_files[i], outname)
def __init__(self):
self.args = train.parse_args()
self.data_loader, self.data_loader_test = train.get_data_loader(
self.args)
self.alpha = float(self.args.alpha)
self.target_acc = [float(x) for x in self.args.target_acc.split(" ")]
self.target_lat = [float(x) for x in self.args.target_lat.split(" ")]
[Tm, Tn, Tr, Tc, Tk, W_p, I_p,
O_p] = [int(x.strip()) for x in self.args.cconv.split(",")]
self.HW = [Tm, Tn, Tr, Tc, Tk, W_p, I_p, O_p]
self.HW2 = [int(x.strip()) for x in self.args.dconv.split(",")]
self.graph = tf.Graph()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
self.sess = tf.Session(config=config, graph=self.graph)
self.hidden_units = controller_params['hidden_units']
if self.args.dataset == "imagenet":
if self.args.model == "resnet18":
self.nn_model_helper = ss_resnet18
elif self.args.model == "mnasnet0_5":
self.nn_model_helper = ss_mnasnet0_5
elif self.args.model == "mobilenet_v2":
self.nn_model_helper = ss_mobilenet_v2
elif self.args.model == "proxyless_mobile":
self.nn_model_helper = ss_proxyless_mobile
elif self.args.model == "mnasnet1_0":
self.nn_model_helper = ss_mnasnet1_0
elif self.args.dataset == "cifar10":
if self.args.model == "resnet18":
self.nn_model_helper = ss_resnet18_cifar
if self.args.model == "big_transfer":
self.nn_model_helper = ss_big_transfer
if self.args.model == "mobilenet_v2":
self.nn_model_helper = ss_mobilenet_cifar
if self.args.model == "densenet121":
self.nn_model_helper = ss_densenet121_cifar
# space_name = self.nn_model_helper.get_space()[0]
space = self.nn_model_helper.get_space()[1]
self.nn1_search_space = space
# self.hw1_search_space = controller_params['hw_space']
self.nn1_num_para = len(self.nn1_search_space)
# self.hw1_num_para = len(self.hw1_search_space)
self.num_para = self.nn1_num_para #+ self.hw1_num_para
self.nn1_beg, self.nn1_end = 0, self.nn1_num_para
# self.hw1_beg, self.hw1_end = self.nn1_end, self.nn1_end + self.hw1_num_para
self.para_2_val = {}
idx = 0
for hp in self.nn1_search_space:
self.para_2_val[idx] = hp
idx += 1
# for hp in self.hw1_search_space:
# self.para_2_val[idx] = hp
# idx += 1
self.RNN_classifier = {}
self.RNN_pred_prob = {}
with self.graph.as_default():
self.build_controller()
self.reward_history = []
self.architecture_history = []
self.trained_network = {}
self.explored_info = {}
self.target_HW_Eff = HW_constraints["target_HW_Eff"]
self.pattern_space = pattern_sets_generate_3((3, 3))
def test_boolean_arguments_case_1(self):
''' train.py:parse_args: check that booleans are correctly parsed '''
arglist = parse_args("--variable-local-rewards".split())
self.assertTrue(arglist.variable_local_rewards)
arglist = parse_args("--variable-local-rewards True".split())
self.assertTrue(arglist.variable_local_rewards)
arglist = parse_args("--variable-local-rewards 1".split())
self.assertTrue(arglist.variable_local_rewards)
arglist = parse_args("--variable-local-rewards y".split())
self.assertTrue(arglist.variable_local_rewards)
arglist = parse_args("")
self.assertFalse(arglist.variable_local_rewards)
arglist = parse_args("--variable-local-rewards False".split())
self.assertFalse(arglist.variable_local_rewards)
arglist = parse_args("--variable-local-rewards 0".split())
self.assertFalse(arglist.variable_local_rewards)
arglist = parse_args("--variable-local-rewards n".split())
self.assertFalse(arglist.variable_local_rewards)
arglist = parse_args("--variable-learning-rate".split())
self.assertTrue(arglist.variable_learning_rate)
arglist = parse_args("--variable-learning-rate True".split())
self.assertTrue(arglist.variable_learning_rate)
arglist = parse_args("--variable-learning-rate 1".split())
self.assertTrue(arglist.variable_learning_rate)
arglist = parse_args("--variable-learning-rate y".split())
self.assertTrue(arglist.variable_learning_rate)
arglist = parse_args("")
self.assertFalse(arglist.variable_learning_rate)
arglist = parse_args("--variable-learning-rate False".split())
self.assertFalse(arglist.variable_learning_rate)
arglist = parse_args("--variable-learning-rate 0".split())
self.assertFalse(arglist.variable_learning_rate)
arglist = parse_args("--variable-learning-rate n".split())
self.assertFalse(arglist.variable_learning_rate)
def test_create_trainer():
args = train.parse_args()
trainer = Trainer(args)
df.to_csv(join(model_dir, 'hyper_df.csv'))
for k, v in grid_results_dict.items():
print(k)
print(v)
with open(join(model_dir, 'grid_search_results.pickle'), 'wb') as f:
pickle.dump(grid_results_dict, f)
del model, trainer, train_loader, loader, validators, best_model, best_results
torch.cuda.empty_cache()
gc.collect()
time.sleep(3)
return grid_results_dict, pd_results
if __name__ == '__main__':
Args, Logger, Model_dir = parse_args()
Train_dataset, Datasets, Word_embs, Ent_embs, File_stores = setup(Args, Logger)
result_dict, pd_dict = grid_search(word_embs=Word_embs,
ent_embs=Ent_embs,
model_dir=Model_dir,
train_dataset=Train_dataset,
datasets=Datasets,
logger=Logger,
args=Args,
file_stores=File_stores)
df = pd.DataFrame(pd_dict)
df.to_csv(join(Model_dir, 'hyper_df.csv'))
def main():
cfg = parse_args()
ckpt_file = 'exp/{}_train_Baseline/ckpt.pth'.format(cfg.train_set)
exp_dir = 'exp/{}_sw_occlusion'.format(cfg.train_set)
# Redirect logs to both console and file.
ReDirectSTD(osp.join(exp_dir, 'stdout_{}.txt'.format(time_str())),
'stdout', False)
ReDirectSTD(osp.join(exp_dir, 'stderr_{}.txt'.format(time_str())),
'stderr', False)
TVT, TMO = set_devices(cfg.sys_device_ids)
# Dump the configurations to log.
import pprint
print('-' * 60)
print('cfg.__dict__')
pprint.pprint(cfg.__dict__)
print('-' * 60)
###########
# Dataset #
###########
im_mean = [0.486, 0.459, 0.408]
im_std = [0.229, 0.224, 0.225]
dataset_kwargs = dict(
resize_h_w=cfg.resize_h_w,
scale=True,
im_mean=im_mean,
im_std=im_std,
batch_dims='NCHW',
num_prefetch_threads=cfg.num_prefetch_threads,
prefetch_size=cfg.prefetch_size,
)
# batch_size=1, final_batch=True, mirror_type=None
train_set_kwargs = dict(
name=cfg.train_set,
part='trainval',
batch_size=1,
final_batch=True,
shuffle=True,
crop_prob=cfg.crop_prob,
crop_ratio=cfg.crop_ratio,
mirror_type=None,
prng=np.random,
)
train_set_kwargs.update(dataset_kwargs)
train_set = create_dataset(**train_set_kwargs)
#########
# Model #
#########
model = Model(
last_conv_stride=cfg.last_conv_stride,
max_or_avg=cfg.max_or_avg,
num_classes=len(set(train_set.labels)),
)
# Model wrapper
model_w = DataParallel(model)
ckpt = torch.load(ckpt_file, map_location=(lambda storage, loc: storage))
model.load_state_dict(ckpt['state_dicts'][0])
print('Loaded model weights from {}'.format(ckpt_file))
model.eval()
# Transfer Models to Specified Device
TMO([model])
############################
# Sliding Window Occlusion #
############################
l = int(np.sqrt(cfg.sw_area * np.prod(cfg.resize_h_w)))
sw_h_w = [l, l]
all_masks = gen_masks(cfg.resize_h_w, sw_h_w, cfg.sw_stride)
h_pos, w_pos = get_sw_positions(cfg.resize_h_w, sw_h_w, cfg.sw_stride)
print('Num of all possible masks: {} * {} = {}'.format(
len(h_pos), len(w_pos), len(all_masks)))
def sw_occlude():
"""Calculate the probability difference caused by occluding different positions."""
im_names, prob_diff = [], []
epoch_done = False
num_ims = 0
st_time = time.time()
last_time = time.time()
# For each image
while not epoch_done:
num_ims += 1
im, im_name, label, _, epoch_done = train_set.next_batch()
im_names.append(im_name[0])
im = Variable(TVT(torch.from_numpy(im).float()))
label = label[0]
# Calculate the original prob.
# feat, logits = model_w(im)
# ori_prob = F.softmax(logits, 1).data.cpu().numpy()[0, label]
# To save time, here just use 1.
ori_prob = 1
probs = []
# In order not to over flood the GPU memory, split into small batches.
for masks in np.array_split(all_masks,
int(len(all_masks) / 32) + 1):
# Repeat an image for num_masks times.
# `im` with shape [1, C, H, W] => `repeated_im` with shape [num_masks, C, H, W]
repeated_im = im.repeat(len(masks), 1, 1, 1)
# Repeat each mask for C times.
# `masks` shape [num_masks, H, W] => [num_masks, C, H, W]
masks = Variable(
TVT(
torch.from_numpy(masks).float().unsqueeze(1).expand_as(
repeated_im)))
# `logits` with shape [num_masks, num_classes]
feat, logits = model_w(repeated_im * masks)
probs_ = F.softmax(logits, 1)
probs_ = probs_.data.cpu().numpy()[:, label].flatten()
probs.append(probs_)
# with shape [num_h_pos, num_w_pos], it can be resized to im shape for visualization
probs = np.reshape(np.concatenate(probs), [len(h_pos), len(w_pos)])
prob_diff.append(ori_prob - probs)
if num_ims % 50 == 0:
print('\t{}/{} images done, +{:.2f}s, total {:.2f}s'.format(
num_ims, len(train_set.im_names),
time.time() - last_time,
time.time() - st_time))
last_time = time.time()
prob_diff = dict(zip(im_names, prob_diff))
return prob_diff
print('Sliding Window Occlusion for Non-mirrored Images.')
train_set.set_mirror_type(None)
prob_diff = dict()
prob_diff['non_mirrored'] = sw_occlude()
print('Sliding Window Occlusion for Mirrored Images.')
train_set.set_mirror_type('always')
prob_diff['mirrored'] = sw_occlude()
save_pickle(prob_diff, osp.join(exp_dir, 'prob_diff.pkl'))
save_pickle(all_masks, osp.join(exp_dir, 'all_masks.pkl'))
for i in range(batch_size):
example_id = batch_map['example_ids'][i]
tokens = sentences[i].tolist()
words = [idx2word[idx] for idx in tokens]
if length == 2:
o = dict(example_id=example_id,
tree=(words[0], words[1]))
elif length == 1:
o = dict(example_id=example_id, tree=words[0])
print(json.dumps(o))
continue
trainer.step(batch_map, train=False, compute_loss=False)
trees = parse_predictor.parse_batch(batch_map)
for ii, tr in enumerate(trees):
example_id = batch_map['example_ids'][ii]
s = [idx2word[idx] for idx in sentences[ii].tolist()]
tr = replace_leaves(tr, s)
o = dict(example_id=example_id, tree=tr)
print(json.dumps(o))
if __name__ == '__main__':
parser = argument_parser()
options = parse_args(parser)
configure(options)
run(options)
def test_train(logger, monkeypatch):
import wandb
import data
from train import Trainer, parse_args
import data.evaluation.multiwoz
from unittest.mock import MagicMock
import tensorboardX
with tempfile.TemporaryDirectory() as d:
with monkeypatch.context() as m:
m.setattr(wandb, 'run', MagicMock())
m.setattr(wandb, 'log', MagicMock())
m.setattr(wandb, 'config', MagicMock())
m.setattr(wandb, 'tensorboard', MagicMock())
m.setattr(tensorboardX, 'SummaryWriter', MagicMock())
wandb.run.dir = d
old_load_dataset = data.load_dataset
m.setattr(
data, 'load_dataset', lambda name, **kwargs: patch_dataset(
old_load_dataset(name, **kwargs)))
m.setattr("sys.argv", ["train.py"])
args = parse_args()
# args.fp16 = True
args.batch_size = 2
args.epochs = 1
args.logging_steps = 1
args.validation_steps = 1
args.evaluation_dialogs = 1
trainer = Trainer(args, logger)
# Patch prediction
old_prediction = trainer._run_prediction
def mock_prediction(*args, **kwargs): # noqa:E306
m.setattr(trainer.dev_predictor.pipeline.predictor,
'max_belief_length', 2)
m.setattr(trainer.dev_predictor.pipeline.predictor,
'max_response_length', 2)
return old_prediction(*args, **kwargs)
m.setattr(trainer, '_run_prediction', mock_prediction)
# Patch evaluation
# old_evaluation = trainer._run_evaluation
# def mock_evaluation(*args, **kwargs): # noqa:E306
# # To speed up the generation
# old_generate = trainer.dev_predictor.predictor.predictor.model.generate
# cached_result = dict()
# def mock_generate(input_ids, *args, **kwargs): # noqa:E306
# nonlocal cached_result
# assert 'eos_token_id' in kwargs
# eos_token_id = kwargs.get('eos_token_id')
# if eos_token_id not in cached_result:
# r = old_generate(*args, input_ids=input_ids, **kwargs)[:, len(input_ids[0]):]
# eos = torch.zeros_like(r).fill_(kwargs.get('eos_token_id'))
# cached_result[eos_token_id] = torch.cat([torch.zeros_like(r), r, eos], 1)
# return torch.cat([input_ids, cached_result[eos_token_id]], 1)
# m.setattr(trainer.dev_predictor.predictor.predictor.model, 'generate', mock_generate)
# m.setattr(trainer.dev_predictor.predictor.predictor, 'max_belief_length', 2)
# m.setattr(trainer.dev_predictor.predictor.predictor, 'max_response_length', 2)
# return old_evaluation(*args, **kwargs)
# m.setattr(trainer, '_run_evaluation', mock_evaluation)
# Patch publish artifact
trainer._publish_artifact = lambda: None
# Run train
trainer.train()
def test_create_trainerbase():
args = train.parse_args()
trainer = TrainerBase(args)
from maddpg_master.experiments import GLOBALS g_env = GLOBALS.global_env from maddpg_master.maddpg.common import tf_util as U from multiagent_particle_envs_master.multiagent import scenarios from multiagent_particle_envs_master.multiagent.environment import MultiAgentEnv from maddpg_master.maddpg.trainer.maddpg import MADDPGAgentTrainer from maddpg_master.maddpg.trainer import replay_buffer import train arg_list = train.parse_args() train.train(arg_list)
