def run(training_folder): logging.info('Start IL...') dataloader = Dataloader(FLAGS.sketch_lengths, FLAGS.il_val_ratio) bot = make(input_dim=39, action_dim=9, arch=FLAGS.arch, hidden_size=FLAGS.hidden_size, nb_slots=FLAGS.nb_slots, env_arch=FLAGS.env_arch, dataloader=dataloader) if FLAGS.cuda: bot = bot.cuda() params = [p for p in bot.parameters()] opt = torch.optim.Adam(params, lr=FLAGS.il_lr) # test dataloader test_sketch_lengths = set(FLAGS.test_sketch_lengths) - set( FLAGS.sketch_lengths) test_dataloader = None if len(test_sketch_lengths) == 0 else Dataloader( test_sketch_lengths, FLAGS.il_val_ratio) try: main_loop(bot, dataloader, opt, training_folder, test_dataloader) except KeyboardInterrupt: pass
def ompn_eval(bot, args): parsing_metric = {} dataloader = Dataloader(args.sketch_lengths, 0.99) bot.eval() for sketch_len in dataloader.env_names: parsing_metric[sketch_len] = DictList() data_iter = dataloader.val_iter(args.episodes, shuffle=True, env_names=[sketch_len]) batch, batch_lens, batch_sketch_lens = data_iter.__next__() with torch.no_grad(): _, extra_info = bot.teacherforcing_batch(batch, batch_lens, batch_sketch_lens, recurrence=64) for batch_id, (length, sketch_length, ps) in tqdm( enumerate(zip(batch_lens, batch_sketch_lens, extra_info.p))): traj = batch[batch_id] traj = traj[:length] _gt_subtask = traj.gt_onsets target = point_of_change(_gt_subtask) # Get prediction sorted ps = ps[:length] ps[0, :-1] = 0 ps[0, -1] = 1 for threshold in [0.2, 0.3, 0.4, 0.5, 0.6, 0.7]: preds = get_boundaries(ps, bot.nb_slots, threshold=threshold, nb_boundaries=len(target)) #parsing_metric[sketch_len].append({'f1_tol{}_thres{}'.format(tol, threshold): # f1(target, preds, tol) for tol in [0, 1, 2]}) _decoded_subtask = get_subtask_seq(length.item(), subtask=traj.tasks.tolist(), use_ids=np.array(preds)) parsing_metric[sketch_len] += { 'task_acc_thres{}'.format(threshold): (_gt_subtask.cpu() == _decoded_subtask.cpu()).tolist() } preds = automatic_get_boundaries_peak(ps, bot.nb_slots, nb_boundaries=len(target)) _decoded_subtask = get_subtask_seq(length.item(), subtask=traj.tasks.tolist(), use_ids=np.array(preds)) parsing_metric[sketch_len] += { 'task_acc_auto': (_gt_subtask.cpu() == _decoded_subtask.cpu()).tolist() } parsing_metric[sketch_len].apply(lambda _t: np.mean(_t)) return parsing_metric
def eval(self): dataloader = Dataloader() c = tf.ConfigProto() c.gpu_options.allow_growth = True with tf.Session(config=c) as sess: checkpoint = tf.train.latest_checkpoint("checkpoint/") if checkpoint: print("restore from: " + checkpoint) self.saver.restore(sess, checkpoint) nn = 0 for inputs in dataloader.get_images(): preds = sess.run(self.output, feed_dict={self.input_tensor: inputs}) dataloader.save_images(str(nn) + ".jpg", preds) nn += 1
def train(self): self.train_step = tf.train.AdamOptimizer(3e-4).minimize(self.loss) dataloader = Dataloader() i = 0 c = tf.ConfigProto() c.gpu_options.allow_growth = True with tf.Session(config=c) as sess: sess.run(tf.global_variables_initializer()) checkpoint = tf.train.latest_checkpoint("checkpoint/") if checkpoint: print("restore from: " + checkpoint) self.saver.restore(sess, checkpoint) elif os.path.exists("vgg16.npy"): print("restore from vgg weights.") vgg = np.load("vgg16.npy", encoding='latin1').item() ops = [] vgg_dict = [ "conv1_1", "conv1_2", "conv2_1", "conv2_2", "conv3_1", "conv3_2", "conv3_3", "conv4_1", "conv4_2", "conv4_3", "conv5_1", "conv5_2", "conv5_3", "fc6", "fc7" ] tf_variables = {} for variables in tf.get_collection( tf.GraphKeys.GLOBAL_VARIABLES): if "Adam" or "RMS" in variables.name: continue key = variables.name.split("/")[0].split(":")[0] if key not in vgg_dict: continue if key not in tf_variables: tf_variables[key] = [variables] ops.append(variables.assign(vgg[key][0])) else: tf_variables[key].append(variables) ops.append(variables.assign(vgg[key][1])) sess.run(ops) for inputs, labels in dataloader.generate(): _, lo, preds = sess.run( [self.train_step, self.loss, self.output], feed_dict={ self.input_tensor: inputs, self.label_tensor: labels }) print(i, lo) if i % 20 == 0: dataloader.save_images("output.jpg", preds) dataloader.save_images("label.jpg", labels) i += 1 if i % 100 == 99: self.saver.save(sess, "checkpoint/ckpt")
def taco_eval(bot, args): parsing_metric = {} dataloader = Dataloader(args.sketch_lengths, 0.99) bot.eval() for sketch_len in dataloader.env_names: parsing_metric[sketch_len] = DictList() data_iter = dataloader.val_iter(args.episodes, shuffle=True, env_names=[sketch_len]) batch, batch_lens, batch_sketch_lens = data_iter.__next__() with torch.no_grad(): parsing_res, _ = taco_decode(bot, trajs=batch, lengths=batch_lens, subtask_lengths=batch_sketch_lens, dropout_p=0., decode=True) parsing_metric[sketch_len].append(parsing_res) parsing_metric[sketch_len].apply(lambda _t: _t[0].item()) return parsing_metric
def main(): parser = argparse.ArgumentParser(description='D2L Linear Regression') parser.add_argument('--run_mode', type=str, nargs='?', default='mxnet', help='input run_mode. "raw" or "mxnet"') args = parser.parse_args() run_mode = args.run_mode num_inputs = 2 num_examples = 1000 batch_size = 10 lr = 0.03 # Learning rate num_epochs = 10 # Number of iterations print(f'run {run_mode} code ...') if run_mode == 'raw': data_loader = Dataloader(TRUE_W, TRUE_B, num_inputs, num_examples, batch_size) features, labels = data_loader.get_data() model = LinearModel(num_inputs, lr, batch_size) for epoch in range(num_epochs): # Assuming the number of examples can be divided by the batch size, all # the examples in the training data set are used once in one epoch # iteration. The features and tags of mini-batch examples are given by X # and y respectively for X, y in data_loader.data_iter(): with autograd.record(): # Minibatch loss in X and y l = model.squared_loss(model.linreg(X), y) l.backward() # Compute gradient on l with respect to [w,b] model.sgd() # sgd([w, b], lr, batch_size) # Update parameters using their gradient train_l = model.squared_loss(model.linreg(features), labels) print('epoch %d, loss %f' % (epoch + 1, train_l.mean().asnumpy())) else: data_loader = MxDataLoader(TRUE_W, TRUE_B, num_inputs, num_examples, batch_size) features, labels = data_loader.get_data() model = MxLinearModel(lr) for epoch in range(num_epochs): for X, y in data_loader.data_iter: with autograd.record(): l = model.loss(model.net(X), y) l.backward() model.trainer.step(batch_size) l = model.loss(model.net(features), labels) print('epoch %d, loss: %f' % (epoch, l.mean().asnumpy())) model.print_result(TRUE_W, TRUE_B)
from data.Dataloader import * from utils.general_utils import * data_path = 'C:/Users/harsh/Downloads/Assignments/Spring 2020/CS 766 Computer Vision/Project/Data/17flowers' image_size = 256 batch_size = 2 image_format = 'jpg' loader = Dataloader(data_path, image_size, batch_size=batch_size, image_format=image_format, validation_required=(True, 0.2, 'train_validation_split')) trainloader, validloader = loader.get_data_loader() generate_sample(trainloader)
def main(training_folder): logging.info('start taco...') dataloader = Dataloader(FLAGS.sketch_lengths, 0.2) model = ModularPolicy(nb_subtasks=10, input_dim=39, n_actions=9, a_mu=dataloader.a_mu, a_std=dataloader.a_std, s_mu=dataloader.s_mu, s_std=dataloader.s_std) if FLAGS.cuda: model = model.cuda() optimizer = torch.optim.Adam(model.parameters(), lr=FLAGS.taco_lr) train_steps = 0 writer = SummaryWriter(training_folder) train_iter = dataloader.train_iter(batch_size=FLAGS.taco_batch_size) nb_frames = 0 curr_best = np.inf train_stats = DictList() # test dataloader test_sketch_lengths = set(FLAGS.test_sketch_lengths) - set(FLAGS.sketch_lengths) test_dataloader = None if len(test_sketch_lengths) == 0 else Dataloader(test_sketch_lengths, FLAGS.il_val_ratio) scheduler = DropoutScheduler() while True: if train_steps > FLAGS.taco_train_steps: logging.info('Reaching maximum steps') break if train_steps % FLAGS.taco_eval_freq == 0: val_metrics = evaluate_loop(dataloader, model, dropout_p=scheduler.dropout_p) logging_metrics(nb_frames, train_steps, val_metrics, writer, 'val') if test_dataloader is not None: test_metrics = evaluate_loop(test_dataloader, model, dropout_p=scheduler.dropout_p) logging_metrics(nb_frames, train_steps, test_metrics, writer, 'test') avg_loss = [val_metrics[env_name].loss for env_name in val_metrics] avg_loss = np.mean(avg_loss) if avg_loss < curr_best: curr_best = avg_loss logging.info('Save Best with loss: {}'.format(avg_loss)) # Save the checkpoint with open(os.path.join(training_folder, 'bot_best.pkl'), 'wb') as f: torch.save(model, f) model.train() train_batch, train_lengths, train_subtask_lengths = train_iter.__next__() if FLAGS.cuda: train_batch.apply(lambda _t: _t.cuda()) train_lengths = train_lengths.cuda() train_subtask_lengths = train_subtask_lengths.cuda() start = time.time() train_outputs = teacherforce_batch(modular_p=model, trajs=train_batch, lengths=train_lengths, subtask_lengths=train_subtask_lengths, decode=False, dropout_p=scheduler.dropout_p) optimizer.zero_grad() train_outputs['loss'].backward() optimizer.step() train_steps += 1 scheduler.step() nb_frames += train_lengths.sum().item() end = time.time() fps = train_lengths.sum().item() / (end - start) train_outputs['fps'] = torch.tensor(fps) train_outputs = DictList(train_outputs) train_outputs.apply(lambda _t: _t.item()) train_stats.append(train_outputs) if train_steps % FLAGS.taco_eval_freq == 0: train_stats.apply(lambda _tensors: np.mean(_tensors)) logger_str = ['[TRAIN] steps={}'.format(train_steps)] for k, v in train_stats.items(): logger_str.append("{}: {:.4f}".format(k, v)) writer.add_scalar('train/' + k, v, global_step=nb_frames) logging.info('\t'.join(logger_str)) train_stats = DictList() writer.flush()
elif '-l' in opt: LR = float(opt[1]) elif '-d' in opt: DIMS = int(opt[1]) elif '-b' in opt: BETA = float(opt[1]) elif '-g' in opt: BVAE = 'g' if model is None: model = BVAEs[BVAE](device, z_dim=DIMS) data_file = np.load('data/dsprites_ndarray_co1sh3sc6or40x32y32_64x64.npz', encoding='bytes') if action == 'train': train_dl = Dataloader(device, data_file['imgs'], TRAIN_BATCH) optim = torch.optim.Adam(model.parameters(), lr=LR) scheduler = torch.optim.lr_scheduler.StepLR(optim, S_SZ, S_MUL, verbose=True) name = '{}_{}_b{}_{}.tm'.format(BVAE, datetime.datetime.now().strftime('%m%d_%H_%M'), BETA, DIMS) try: loss = train(train_dl, model, optim, BETA, EPOCHS, scheduler) torch.save(model.state_dict(), './models/' + name) output.print('model', name) output.print('loss', loss) except KeyboardInterrupt: s = input('Do you want to save the model? ') if s == 'y': torch.save(model.state_dict(), './models/' + name)
def main(cmd_args): """Run the main training function.""" parser = get_parser() args, _ = parser.parse_known_args(cmd_args) # logging info if args.verbose > 0: logging.basicConfig( level=logging.INFO, format= "%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s", ) else: logging.basicConfig( level=logging.WARN, format= "%(asctime)s (%(module)s:%(lineno)d) %(levelname)s: %(message)s", ) logging.warning("Skip DEBUG/INFO messages") # set random seed logging.info("random seed = %d" % args.seed) random.seed(args.seed) np.random.seed(args.seed) # load dictionary for debug log if args.dict is not None: with open(args.dict, "rb") as f: dictionary = f.readlines() char_list = [ entry.decode("utf-8").split(" ")[0] for entry in dictionary ] char_list.insert(0, "<blank>") char_list.append("<eos>") args.char_list = char_list else: args.char_list = None with open(args.valid_json, "rb") as f: valid_json = json.load(f)["utts"] utts = list(valid_json.keys()) idim = int((valid_json[utts[0]]["input"][0]["shape"][-1])) odim = int(valid_json[utts[0]]["output"][0]["shape"][-1]) logging.info("input dims: " + str(idim)) logging.info("#output dims: " + str(odim)) # data Data = Dataloader(args) # model Model = Transducer(idim, odim, args) # update saved model call_back = ModelCheckpoint(monitor='val_loss', dirpath=args.outdir) # train model trainer = Trainer(gpus=args.ngpu, callbacks=[call_back], max_epochs=args.epochs, resume_from_checkpoint=args.resume) trainer.fit(Model, Data)
def main(training_folder): logging.info('Start compile...') dataloader = Dataloader(FLAGS.sketch_lengths, 0.2) model = compile.CompILE(vec_size=39, hidden_size=FLAGS.hidden_size, action_size=9, env_arch=FLAGS.env_arch, max_num_segments=FLAGS.compile_max_segs, latent_dist=FLAGS.compile_latent, beta_b=FLAGS.compile_beta_b, beta_z=FLAGS.compile_beta_z, prior_rate=FLAGS.compile_prior_rate, dataloader=dataloader) if FLAGS.cuda: model = model.cuda() optimizer = torch.optim.Adam(model.parameters(), lr=FLAGS.compile_lr) train_steps = 0 writer = SummaryWriter(training_folder) train_iter = dataloader.train_iter(batch_size=FLAGS.compile_batch_size) nb_frames = 0 curr_best = np.inf train_stats = DictList() while True: if train_steps > FLAGS.compile_train_steps: logging.info('Reaching maximum steps') break if train_steps % FLAGS.compile_eval_freq == 0: # Testing val_metrics = {} model.eval() for env_name in FLAGS.sketch_lengths: val_metrics[env_name] = DictList() val_iter = dataloader.val_iter( batch_size=FLAGS.compile_batch_size, env_names=[env_name]) for val_batch, val_lengths, val_sketch_lens in val_iter: if FLAGS.cuda: val_batch.apply(lambda _t: _t.cuda()) val_lengths = val_lengths.cuda() val_sketch_lens = val_sketch_lens.cuda() with torch.no_grad(): val_outputs, extra_info = model.forward( val_batch, val_lengths, val_sketch_lens) val_metrics[env_name].append(val_outputs) # Parsing total_lengths = 0 total_task_corrects = 0 val_iter = dataloader.val_iter(batch_size=FLAGS.eval_episodes, env_names=[env_name], shuffle=True) val_batch, val_lengths, val_sketch_lens = val_iter.__next__() if FLAGS.cuda: val_batch.apply(lambda _t: _t.cuda()) val_lengths = val_lengths.cuda() val_sketch_lens = val_sketch_lens.cuda() with torch.no_grad(): val_outputs, extra_info = model.forward( val_batch, val_lengths, val_sketch_lens) seg = torch.stack(extra_info['segment'], dim=1).argmax(-1) for batch_id, (length, sketch_length, _seg) in enumerate( zip(val_lengths, val_sketch_lens, seg)): traj = val_batch[batch_id] traj = traj[:length] _gt_subtask = traj.gt_onsets target = point_of_change(_gt_subtask) _seg = _seg[_seg.sort()[1]].cpu().tolist() # Remove the last one because too trivial val_metrics[env_name].append({ 'f1_tol0': f1(target, _seg, 0), 'f1_tol1': f1(target, _seg, 1), 'f1_tol2': f1(target, _seg, 2) }) # subtask total_lengths += length.item() _decoded_subtask = get_subtask_seq( length.item(), subtask=traj.tasks.tolist(), use_ids=np.array(_seg)) total_task_corrects += (_gt_subtask.cpu( ) == _decoded_subtask.cpu()).float().sum() # record task acc val_metrics[ env_name].task_acc = total_task_corrects / total_lengths # Print parsing result lines = [] lines.append('tru_ids: {}'.format(target)) lines.append('dec_ids: {}'.format(_seg)) logging.info('\n'.join(lines)) val_metrics[env_name].apply( lambda _t: torch.tensor(_t).float().mean().item()) # Logger for env_name, metric in val_metrics.items(): line = ['[VALID][{}] steps={}'.format(env_name, train_steps)] for k, v in metric.items(): line.append('{}: {:.4f}'.format(k, v)) logging.info('\t'.join(line)) mean_val_metric = DictList() for metric in val_metrics.values(): mean_val_metric.append(metric) mean_val_metric.apply(lambda t: torch.mean(torch.tensor(t))) for k, v in mean_val_metric.items(): writer.add_scalar('val/' + k, v.item(), nb_frames) writer.flush() avg_loss = [val_metrics[env_name].loss for env_name in val_metrics] avg_loss = np.mean(avg_loss) if avg_loss < curr_best: curr_best = avg_loss logging.info('Save Best with loss: {}'.format(avg_loss)) # Save the checkpoint with open(os.path.join(training_folder, 'bot_best.pkl'), 'wb') as f: torch.save(model, f) model.train() train_batch, train_lengths, train_sketch_lens = train_iter.__next__() if FLAGS.cuda: train_batch.apply(lambda _t: _t.cuda()) train_lengths = train_lengths.cuda() train_sketch_lens = train_sketch_lens.cuda() train_outputs, _ = model.forward(train_batch, train_lengths, train_sketch_lens) optimizer.zero_grad() train_outputs['loss'].backward() optimizer.step() train_steps += 1 nb_frames += train_lengths.sum().item() train_outputs = DictList(train_outputs) train_outputs.apply(lambda _t: _t.item()) train_stats.append(train_outputs) if train_steps % FLAGS.compile_eval_freq == 0: train_stats.apply(lambda _tensors: np.mean(_tensors)) logger_str = ['[TRAIN] steps={}'.format(train_steps)] for k, v in train_stats.items(): logger_str.append("{}: {:.4f}".format(k, v)) writer.add_scalar('train/' + k, v, global_step=nb_frames) logging.info('\t'.join(logger_str)) train_stats = DictList() writer.flush()