def main(args): # Create model directory for saving trained models if not os.path.exists(args.model_path): os.makedirs(args.model_path) val_dataset = a2d_dataset.A2DDataset(val_cfg, args.dataset_path) data_loader = DataLoader(val_dataset, batch_size=1, shuffle=False, num_workers=1) model = resnet152(pretrained=True) model.fc = torch.nn.Linear(2048, 43) model = model.to(device) model.load_state_dict(torch.load(os.path.join(args.model_path, 'net.ckpt'))) X = np.zeros((data_loader.__len__(), args.num_cls)) Y = np.zeros((data_loader.__len__(), args.num_cls)) print(data_loader.__len__()) model.eval() with torch.no_grad(): for batch_idx, data in enumerate(data_loader): # mini-batch images = data[0].to(device) labels = data[1].type(torch.FloatTensor).to(device) output = model(images).cpu().detach().numpy() target = labels.cpu().detach().numpy() output[output >= 0.1] = 1 output[output < 0.1] = 0 X[batch_idx, :] = output Y[batch_idx, :] = target P = Precision(X, Y) R = Recall(X, Y) F = F1(X, Y) print('Precision: {:.1f} Recall: {:.1f} F1: {:.1f}'.format(100 * P, 100 * R, 100 * F))
def eval_on_validation(): if not os.path.exists(config.run_dir): os.mkdir(config.run_dir) model = getattr(models, config.model)() model = torch.nn.DataParallel(model) # multi-gpu model.cuda() print 'test on validation set.', config.model print model if config.load_model_path: model.load_state_dict(torch.load(config.load_model_path)) # data test_data = KITTIRoadFusion(config.root, split='val', num_features=19) test_dataloader = DataLoader(test_data, batch_size=1, shuffle=False, num_workers=4) # test model.eval() eval_acc = 0 eval_acc_cls = 0 eval_mean_iu = 0 eval_fwavacc = 0 li_pred = [] li_gt = [] total_time = 0 for i, (name, im, cloud, theta, shift, lb) in enumerate(test_dataloader): im, cloud, theta, shift, lb = Variable(im), Variable(cloud), Variable(theta), Variable(shift), Variable(lb) im, cloud, theta, shift, lb = im.float().cuda(), cloud.float().cuda(), theta.float().cuda(), shift.float().cuda(), lb.long().cuda() start = time.clock() _, pred = model(im, cloud, theta, shift) # inference end = time.clock() total_time += (end-start) # pred = F.upsample_bilinear(pred, scale_factor=4) # save image label_pred = pred.data.cpu().numpy().squeeze() label_pred = np.array(label_pred*255, dtype=np.uint8) filename = os.path.join(config.run_dir, name[0]) print filename # cv2.imwrite(filename, label_pred) # Mean IoU label_true = lb.data.cpu().numpy().astype(np.int8) label_pred = pred.data.cpu().numpy().squeeze(0) label_pred = (label_pred > 0.5).astype(np.int8) for (label, prob) in zip(label_true, label_pred): acc, acc_cls, mean_iu, fwavacc = label_accuracy_score(label, prob, n_class=2) eval_acc += acc eval_acc_cls += acc_cls eval_mean_iu += mean_iu eval_fwavacc += fwavacc # MaxF label_pred = pred.data.cpu().numpy().squeeze() label_true = lb.data.cpu().numpy().squeeze() li_pred.append(label_pred) li_gt.append(label_true) print 'Runtime ############# time(s) : %f ##########' % (total_time / test_dataloader.__len__()) print 'Validation ======ACC: %lf,Mean IoU: %lf======' % (eval_acc / test_dataloader.__len__(), eval_mean_iu / test_dataloader.__len__()) eval_road(li_pred, li_gt)
def eval_on_validation_bev(): if not os.path.exists(config.run_dir): os.mkdir(config.run_dir) model = getattr(models, config.model)() model = torch.nn.DataParallel(model) # multi-gpu model.cuda() print 'test on validation set.', config.model print model if config.load_model_path: model.load_state_dict(torch.load(config.load_model_path)) # data bev = BirdsEyeView() test_data = KITTIRoadFusion(config.root, split='val', num_features=19, return_bev=True) test_dataloader = DataLoader(test_data, batch_size=1, shuffle=False, num_workers=4) # test model.eval() eval_acc = 0 eval_acc_cls = 0 eval_mean_iu = 0 eval_fwavacc = 0 li_pred = [] li_gt = [] for i, (name, im, cloud, theta, shift, _, lb) in enumerate(test_dataloader): im, cloud, theta, shift, lb = Variable(im), Variable(cloud), Variable(theta), Variable(shift), Variable(lb) im, cloud, theta, shift, lb = im.float().cuda(), cloud.float().cuda(), theta.float().cuda(), shift.float().cuda(), lb.long().cuda() _, pred = model(im, cloud, theta, shift) # inference pred = pred.data.cpu().numpy().squeeze() theta = theta.data.cpu().numpy().squeeze() shift = shift.data.cpu().numpy().squeeze() label_pred = bev.transformLable2BEV((pred*255).astype(np.uint8), theta, shift) label_true = lb.data.cpu().numpy().squeeze() # save image filename = os.path.join(config.run_dir, name[0]) print filename cv2.imwrite(filename, label_pred) label_pred = label_pred/255. # Mean IoU label_true_hard = np.expand_dims(label_true.astype(np.int8), axis=0) label_pred_hard = np.expand_dims((label_pred > 0.5).astype(np.int8), axis=0) for (label, prob) in zip(label_true_hard, label_pred_hard): acc, acc_cls, mean_iu, fwavacc = label_accuracy_score(label, prob, n_class=2) eval_acc += acc eval_acc_cls += acc_cls eval_mean_iu += mean_iu eval_fwavacc += fwavacc # MaxF li_pred.append(label_pred) li_gt.append(label_true) print 'Validation ======ACC: %lf,Mean IoU: %lf======' % (eval_acc / test_dataloader.__len__(), eval_mean_iu / test_dataloader.__len__()) eval_road(li_pred, li_gt)
def main(args): # Create model directory for saving trained models if not os.path.exists(args.model_path): os.makedirs(args.model_path) test_dataset = a2d_dataset.A2DDataset(train_cfg, args.dataset_path) data_loader = DataLoader(test_dataset, batch_size=1, shuffle=False, num_workers=1) # define load your model here model_1 = net('efficientnet_b7') model_1.cuda() model_1.load_state_dict( torch.load(os.path.join(args.model_path, 'efficientnetb7_F53.8.ckpt'))) model_2 = net('efficientnet_b7') model_2.cuda() model_2.load_state_dict( torch.load( os.path.join(args.model_path, 'efficientnetb7_val_53.7.ckpt'))) X = np.zeros((data_loader.__len__(), args.num_cls)) Y = np.zeros((data_loader.__len__(), args.num_cls)) print(data_loader.__len__()) model_1.eval() model_2.eval() with torch.no_grad(): for batch_idx, data in enumerate(data_loader): # mini-batch images = data[0].to(device) labels = data[1].type(torch.FloatTensor).to(device) # output = model(images).cpu().detach().numpy() output_1 = model_1(images) # output_1 = (torch.nn.functional.sigmoid(output_1)).cpu().detach().numpy() output_2 = model_2(images) # output_2 = (torch.nn.functional.sigmoid(output_2)).cpu().detach().numpy() output = (output_1 + output_2) / 2 output = ( torch.nn.functional.sigmoid(output)).cpu().detach().numpy() target = labels.cpu().detach().numpy() output[output >= 0.4] = 1 output[output < 0.4] = 0 X[batch_idx, :] = output Y[batch_idx, :] = target P = Precision(X, Y) R = Recall(X, Y) F = F1(X, Y) print('Precision: {:.1f} Recall: {:.1f} F1: {:.1f}'.format( 100 * P, 100 * R, 100 * F))
def test(self, data_set, is_cnn=False, print_detail=False): """ Validate this model with corresponding test set. :param data_set: Test set, QuestionSet type. :param is_cnn: Is this model based on cnn or not. :param print_detail: Print every sample and its result in the test set or not. :return: A tuple with hit number and accuracy rate. """ data_loader = DataLoader(data_set) acc = 0 for t, (cla, test) in enumerate(data_loader): vote = {} if self.model == 'cnn' or is_cnn: test = self.normalize(test) for net in self.classifiers: net.eval() output = net(test) _, pred = torch.max(output.data, 1) pred = data_set.index2label(pred) if pred in vote.keys(): vote[pred] += 1 else: vote[pred] = 1 voted_pred = sorted(vote.items(), key=lambda x: x[1], reverse=True)[0][0] y = data_set.index2label(cla) if y == voted_pred: acc += 1 if print_detail: question = data_set.index2question(t) print('%s %s -> %s ' % (y, question, voted_pred)) acc_rate = float(acc) / float(data_loader.__len__()) return acc, acc_rate
def eval_on_validation(): if not os.path.exists(config.run_dir): os.mkdir(config.run_dir) model = getattr(models, config.model)() model = torch.nn.DataParallel(model) # multi-gpu model.cuda() print 'test', config.model print model if config.load_model_path: model.load_state_dict(torch.load(config.load_model_path)) # data test_data = KITTIRoadFusion(config.root, split='val', num_features=19) test_dataloader = DataLoader(test_data, batch_size=1, shuffle=False, num_workers=4) # test model.eval() total_time = 0 for i, (name, _, cloud, _, _, _) in enumerate(test_dataloader): cloud = Variable(cloud) cloud = cloud.float().cuda() start = time.clock() pred = model(cloud) # inference end = time.clock() total_time += (end - start) pred = pred.data.cpu().numpy().squeeze() pred = np.array(pred * 255, dtype=np.uint8) filename = os.path.join(config.run_dir, name[0]) print filename # cv2.imwrite(filename, pred) print 'Runtime ############# time(s) : %f ##########' % ( total_time / test_dataloader.__len__())
class ValidationLoader: def __init__(self, dataset_path, label_path, input_size, is_grey_scale, batch_size=64, num_workers=0, pin_memory=True): self.input_size = input_size self.batch_size = batch_size self.num_workers = num_workers self.pin_memory = pin_memory self.validation_data_path = dataset_path self.validation_label_path = label_path self.is_grey_scale = is_grey_scale # Data augmentation and normalization self.validation_trans = transforms.Compose([ transforms.Resize(self.input_size), transforms.ToTensor(), ]) self.ValidationDataLoader = DataLoader(ImageCSVLoader( self.validation_trans, self.validation_data_path, self.validation_label_path, self.is_grey_scale), batch_size=batch_size, num_workers=num_workers, shuffle=True, pin_memory=pin_memory) def __len__(self): return self.ValidationDataLoader.__len__()
def main(args): # Create model directory for saving trained models if not os.path.exists(args.model_path): os.makedirs(args.model_path) test_dataset = a2d_dataset.A2DDataset_test(test_cfg, args.dataset_path) data_loader = DataLoader(test_dataset, batch_size=1, shuffle=False, num_workers=1) # define and load pre-trained model model = net('se_resnext101') model.cuda() model.load_state_dict( torch.load( os.path.join(args.model_path, 'seresnext_mode_train_56.2_57.8.ckpt'))) results = np.zeros((data_loader.__len__(), args.num_cls)) model.eval() # prediction and saving with torch.no_grad(): for batch_idx, data in enumerate(data_loader): # mini-batch images = data.to(device) output = model(images) output = ( torch.nn.functional.sigmoid(output)).cpu().detach().numpy() output[output >= 0.4] = 1 output[output < 0.4] = 0 results[batch_idx, :] = output with open('results_netid.pkl', 'wb') as f: pickle.dump(results, f)
def main(): logger.info("Load Config") data_and_support = CortexEpfl() cfg = config.load_config(data_and_support.name) logger.info("Initialize Experiment") trial_path, trial_id, log_msg = init(cfg) logger.info('Experiment ID: {}, Trial ID: {}, GPU: {}'.format(cfg.experiment_idx, trial_id, GPU_index)) logger.info("Network config") model_config = NetworkConfig(cfg.step_count, cfg.first_layer_channels, cfg.num_classes, cfg.num_input_channel, True, cfg.ndims, 'same', trial_id, cfg.batch_size, cfg) logger.info("Create network") classifier = network(model_config) classifier.cuda() logger.info("Load data") cfg.patch_shape = model_config.in_out_shape(cfg.hint_patch_shape) data = data_and_support.load_data(cfg) loader = DataLoader(data[DataModes.TRAINING], batch_size=classifier.config.batch_size, shuffle=True) logger.info("Trainset length: {}".format(loader.__len__())) logger.info("Initialize optimizer") optimizer = optim.Adam(filter(lambda p: p.requires_grad, classifier.parameters()), lr=cfg.learning_rate) logger.info("Initialize evaluator") evaluator = Evaluator(classifier, optimizer, data, trial_path, cfg, data_and_support, cfg.train_mode) logger.info("Initialize trainer") trainer = Trainer(classifier, loader, optimizer, cfg.numb_of_epochs, cfg.eval_every, trial_path, evaluator, log_msg) trainer.train()
def main(): from visdom import Visdom import time import torchvision # viz = Visdom() db = Medical(NOR_path, TUM_path, 224, "train") x, y = next(iter(db)) # xx = x[4:7, ...] # viz.image(xx, win="sample_x", opts=dict(title="sample_x")) print("sample", x.shape, y.shape, y) loader = DataLoader(db, batch_size=32, shuffle=True, num_workers=4) print("loader", loader.__len__()) i = 0 for x, y in loader: print("第", i, "个") i = i + 1 xx = x[:, 0:3, ...] # print("x.shape=",xx.shape) # viz.images( xx, nrow=4, win="batch", opts=dict(title="batch")) # viz.text(str(y.numpy()), win="lablel", opts=dict(title="batch-y")) # time.sleep(20) """
def evaluate_model(): dataset = CommentDataset(mode='val') trainloader = DataLoader(dataset, batch_size=dataset.__len__(), shuffle=False, num_workers=4) net = load_model(os.path.join('pretrained models', MODEL_NAME)) criterion = nn.BCELoss() device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") running_loss = 0.0 score = dict(zip(CLASSES, [0.] * NUM_CLASSES)) with torch.no_grad(): for i, data in enumerate(trainloader): X, y = data X = X.to(device) y = y.to(device) outputs = net(X) loss = criterion(outputs, y) running_loss += loss.item() for ax, key in enumerate(list(score.keys())): score[key] += roc_auc_score(y[..., ax].cpu().numpy(), outputs[..., ax].cpu().numpy()) print(f'Evaluate loss = {running_loss/trainloader.__len__()}') for ax, key in enumerate(list(score.keys())): score[key] /= trainloader.__len__() print(f'ROC_AUC score = {score}') print(f'Mean ROC_AUC score = {np.mean(list(score.values()))}')
def main(): from model.voxel2mesh import Voxel2Mesh as network exp_id = 2 # Initialize cfg = load_config(exp_id) trial_path, trial_id = init(cfg) print('Experiment ID: {}, Trial ID: {}'.format(cfg.experiment_idx, trial_id)) print("Create network") classifier = network(cfg) classifier.cuda() wandb.init(name='Experiment_{}/trial_{}'.format(cfg.experiment_idx, trial_id), project="vm-net", dir='/cvlabdata1/cvlab/datasets_udaranga/experiments/wanb') print("Initialize optimizer") optimizer = optim.Adam(filter(lambda p: p.requires_grad, classifier.parameters()), lr=cfg.learning_rate) print("Load data") data_obj = Chaos() # During the first run use load_data function. It will do the necessary preprocessing and save the files to disk. # data = data_obj.pre_process_dataset(cfg, trial_id) data = data_obj.quick_load_data(cfg, trial_id) loader = DataLoader(data[DataModes.TRAINING], batch_size=classifier.config.batch_size, shuffle=True) print("Trainset length: {}".format(loader.__len__())) print("Initialize evaluator") evaluator = Evaluator(classifier, optimizer, data, trial_path, cfg, data_obj) print("Initialize trainer") trainer = Trainer(classifier, loader, optimizer, cfg.numb_of_itrs, cfg.eval_every, trial_path, evaluator) if cfg.trial_id is not None: print("Loading pretrained network") save_path = trial_path + '/best_performance/model.pth' checkpoint = torch.load(save_path) classifier.load_state_dict(checkpoint['model_state_dict']) optimizer.load_state_dict(checkpoint['optimizer_state_dict']) epoch = checkpoint['epoch'] else: epoch = 0 trainer.train(start_iteration=epoch)
def train(model): step = 0 nr_eval = 0 dataset = VimeoDataset('train', loaddata=True) sampler = DistributedSampler(dataset) train_data = DataLoader(dataset, batch_size=args.batch_size, num_workers=8, pin_memory=True, drop_last=True, sampler=sampler) args.step_per_epoch = train_data.__len__() dataset_val = VimeoDataset('validation', loaddata=True) val_data = DataLoader(dataset_val, batch_size=16, pin_memory=True, num_workers=8) evaluate(model, val_data, nr_eval) model.save_model(log_path, local_rank) model.load_model(log_path, local_rank) print('training...') time_stamp = time.time() for epoch in range(args.epoch): sampler.set_epoch(epoch) for i, data in enumerate(train_data): data_time_interval = time.time() - time_stamp time_stamp = time.time() data_gpu, flow_gt = data data_gpu = data_gpu.to(device, non_blocking=True) / 255. flow_gt = flow_gt.to(device, non_blocking=True) imgs = data_gpu[:, :6] gt = data_gpu[:, 6:9] mul = np.cos(step / (args.epoch * args.step_per_epoch) * math.pi) * 0.5 + 0.5 learning_rate = get_learning_rate(step) pred, merged_img, flow, loss_l1, loss_flow, loss_cons, loss_ter, flow_mask = model.update(imgs, gt, learning_rate, mul, True, flow_gt) train_time_interval = time.time() - time_stamp time_stamp = time.time() #if step % 100 == 1 and local_rank == 0: writer.add_scalar('learning_rate', learning_rate, step) writer.add_scalar('loss_l1', loss_l1, step) writer.add_scalar('loss_flow', loss_flow, step) writer.add_scalar('loss_cons', loss_cons, step) writer.add_scalar('loss_ter', loss_ter, step) if step % 1000 == 1 and local_rank == 0: gt = (gt.permute(0, 2, 3, 1).detach().cpu().numpy() * 255).astype('uint8') pred = (pred.permute(0, 2, 3, 1).detach().cpu().numpy() * 255).astype('uint8') merged_img = (merged_img.permute(0, 2, 3, 1).detach().cpu().numpy() * 255).astype('uint8') flow = flow.permute(0, 2, 3, 1).detach().cpu().numpy() flow_mask = flow_mask.permute(0, 2, 3, 1).detach().cpu().numpy() flow_gt = flow_gt.permute(0, 2, 3, 1).detach().cpu().numpy() for i in range(5): imgs = np.concatenate((merged_img[i], pred[i], gt[i]), 1)[:, :, ::-1] writer.add_image(str(i) + '/img', imgs, step, dataformats='HWC') writer.add_image(str(i) + '/flow', flow2rgb(flow[i]), step, dataformats='HWC') writer.add_image(str(i) + '/flow_gt', flow2rgb(flow_gt[i]), step, dataformats='HWC') writer.add_image(str(i) + '/flow_mask', flow2rgb(flow[i] * flow_mask[i]), step, dataformats='HWC') writer.flush() if local_rank == 0: print('epoch:{} {}/{} time:{:.2f}+{:.2f} loss_l1:{:.4e}'.format(epoch, i, args.step_per_epoch, data_time_interval, train_time_interval, loss_l1)) step += 1 nr_eval += 1 if nr_eval % 5 == 0: evaluate(model, val_data, step) model.save_model(log_path, local_rank) dist.barrier()
def eval(args): # load model # model = get_model(args, 0, args.r, from_ckpt=True, train=False) # model.load(args.logname) # from default checkpoint num = 49 model = torch.load(folder + "model_epoch_"+str(num)+".pth") avg_psnr = 0 avg_snr = 0 sum_x = 0 sum_y = 0 val_dir = '../data/vctk/vctk-speaker1-val.4.16000.8192.4096.h5' file_list = '../data/vctk/speaker1/speaker1-val-files.txt' # X_val, Y_val = load_h5(args.val) # dataset = loading(root_dir, transform=None) valset1 = loading(val_dir, transform=None) valset = DataLoader(valset1, batch_size=1, shuffle=False, num_workers=4) nb_batch = valset.__len__() with torch.no_grad(): for i_batch, val in enumerate(valset): # for batch in range(nb_batch): # input, target = batch[0].to(device), batch[1].to(device) X_val, Y_val = val['lr'], val['hr'] # print(X_val.numpy()[0].shape) # x_temp = X_val.numpy()[0] # y_temp = Y_val.numpy()[0] # x_S = computeSNR(x_temp,2048) # y_S = computeSNR(y_temp,2048) # sum_x += x_S # sum_y += y_S X_val = X_val.float() Y_val = Y_val.float() X_val = Variable(X_val.cuda(), requires_grad=False).permute(0, 2, 1) # compute N, C L Y_val = Variable(Y_val.cuda(), requires_grad=False).permute(0, 2, 1) # print(X_val.size()) # print(Y_val.size()) prediction = model(X_val) mse = loss_function(prediction, Y_val) psnr = 10 * log10(1 / mse.item()) snr = 10 * log10(1 / mse.cpu().data.numpy()) avg_psnr += psnr avg_snr += snr print("===> Avg. SNR: {:.4f} dB".format(avg_snr / len(valset))) # print("===> X. SNR: {:.4f} dB".format(sum_x / len(valset))) # print("===> Y. SNR: {:.4f} dB".format(sum_y / len(valset))) with open(file_list) as f: for line in f: try: print(line.strip()) upsample_wav(line.strip(), model) except EOFError: print('WARNING: Error reading file:', line.strip())
def main(): exp_id = 3 # Initialize cfg = load_config(exp_id) trial_path, trial_id = init(cfg) print('Experiment ID: {}, Trial ID: {}'.format(cfg.experiment_idx, trial_id)) print("Create network") classifier = network(cfg) classifier.cuda() wandb.init(name='Experiment_{}/trial_{}'.format(cfg.experiment_idx, trial_id), project="vm-net", dir=trial_path) print("Initialize optimizer") optimizer = optim.Adam(filter(lambda p: p.requires_grad, classifier.parameters()), lr=cfg.learning_rate) print("Load pre-processed data") data_obj = cfg.data_obj data = data_obj.quick_load_data(cfg, trial_id) loader = DataLoader(data[DataModes.TRAINING], batch_size=classifier.config.batch_size, shuffle=True) print("Trainset length: {}".format(loader.__len__())) print("Initialize evaluator") evaluator = Evaluator(classifier, optimizer, data, trial_path, cfg, data_obj) print("Initialize trainer") trainer = Trainer(classifier, loader, optimizer, cfg.numb_of_itrs, cfg.eval_every, trial_path, evaluator) if cfg.trial_id is not None: print("Loading pretrained network") save_path = trial_path + '/best_performance/model.pth' checkpoint = torch.load(save_path) classifier.load_state_dict(checkpoint['model_state_dict']) optimizer.load_state_dict(checkpoint['optimizer_state_dict']) epoch = checkpoint['epoch'] else: epoch = 0 trainer.train(start_iteration=epoch)
def train(args): # get data root_dir = '../data/vctk/vctk-speaker1-train.4.16000.8192.4096.h5' # val_dir = '../data/vctk/vctk-speaker1-val.4.16000.8192.4096.h5' dataset1 = loading(root_dir, transform=None) # valset1 = loading(val_dir, transform=None) dataset = DataLoader(dataset1, batch_size=64, shuffle=True, num_workers=4) # valset = DataLoader(valset1, batch_size=4, shuffle=True, num_workers=4) #dataset = dataset1 # valset = valset1 nb_batch = dataset.__len__() epoch_l = [] iter_num = [] # start training process i = 0 for epoch in range(args.epochs): epoch_loss = 0 n = 0 start = time.time() for i_batch, data in enumerate(dataset): X_train, Y_train = data['lr'], data['hr'] #for batch in range(nb_batch): # for batch in enumerate(dataset, 1): X_train = X_train.float() Y_train = Y_train.float() X_train = Variable(X_train.cuda(), requires_grad=False).permute(0, 2, 1) Y_train = Variable(Y_train.cuda(), requires_grad=False).permute(0, 2, 1) model.zero_grad() optimizer.zero_grad() loss = loss_function((model(X_train)), Y_train) # not sure yet #epoch_loss += loss.item() epoch_loss += loss.cpu().data.numpy() loss.backward() optimizer.step() n = n + 1 i = i + 1 end = time.time() epoch_l.append(epoch_loss/n) iter_num.append(i) # print(i) print("== Epoch {%s} Loss: {%.4f} Running time: {%4f}" % (str(epoch), (epoch_loss) / n, end - start)) checkpoint(epoch) # store checkpoint fig = plt.figure() plt.plot(iter_num, epoch_l) plt.xlabel('number iteration') plt.ylabel('Loss') plt.savefig(folder+'loss.png')
def ood_iter(self): testset = dset.ImageFolder(root=os.path.join(self.root, 'tiny-imagenet-200/val'), transform=self.ood_transform) rs = torch.utils.data.RandomSampler(testset, True, self.dataset_len) ood_iter = DataLoader(testset, batch_size=self.ood_batch_size, shuffle=False, num_workers=12, pin_memory=True, sampler=rs) ood_iter.metric_set = 'ood' ood_iter.name = self.name ood_iter.__len__ = self.dataset_len return ood_iter
def ood_iter(self): testset = dset.CIFAR10(root=self.root, train=False, download=True, transform=self.ood_transform) rs = torch.utils.data.RandomSampler(testset, True, self.dataset_len) ood_iter = DataLoader(testset, batch_size=self.ood_batch_size, shuffle=False, num_workers=12, pin_memory=True, sampler=rs) ood_iter.metric_set = 'ood' ood_iter.name = self.name ood_iter.__len__ = self.dataset_len return ood_iter
def train(self, dataset, batch_size=1, valdata=None, num_workers=0, load_prev=False, epoch=None): if load_prev: current_epoch = self.load_checkpoint(epoch=epoch) + 1 else: current_epoch = 0 for epoch in range(current_epoch, self.num_epochs): self.actor.train() loss_acc = 0 iter = 0 loader = DataLoader(dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers, collate_fn=self.collate_fn) self.optimizer.zero_grad() val = 0 for batch in loader: loss, val = self.actor(batch, epoch) self.optimizer.zero_grad() print_str = '[Epoch %d, batch %d of %d] ' % ( epoch, iter, loader.__len__() - 1) # only backpropagate of loss is non-zero if loss > 0.0: iter += 1 loss_acc += loss.item() print(print_str, "loss:", loss.item(), "loss_acc: ", loss_acc / iter) loss.backward() self.optimizer.step() self.scheduler.step(epoch=epoch) self.save_checkpoint(self.job_name, epoch, val) if not valdata is None: self.validate(self.job_name, valdata, batch_size, epoch) if self.update_dataset: dataset.generate_samples()
def train_model(): print('Training model...') dataset = CommentDataset(mode='train') trainloader = DataLoader(dataset, batch_size=64, shuffle=True, num_workers=4) # dataiter = iter(trainloader) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") net = Net() net = net.to(device) criterion = nn.BCELoss() optimizer = optim.Adam(net.parameters(), lr=1e-3, weight_decay=1e-5) shutil.rmtree('logs') os.mkdir('logs') writer = SummaryWriter(log_dir='logs') for epoch in range(EPOCHS): # loop over the dataset multiple times print(f'Number epochs - {epoch}') running_loss = 0.0 for i, data in enumerate(trainloader): X, y = data X = X.to(device) y = y.to(device) optimizer.zero_grad() # zero the parameter gradients outputs = net(X) # forward + backward + optimize loss = criterion(outputs, y) loss.backward() optimizer.step() # print statistics running_loss += loss.item() if i % 500 == 499: # print every 500 mini-batches writer.add_scalar(tag='loss', scalar_value=running_loss / 500, global_step=i + trainloader.__len__() * epoch) print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 500)) running_loss = 0.0 save_model(os.path.join('pretrained models', MODEL_NAME), net) print('Finished Training')
def main(): net = SynthesizeBlur() blur_dataset = BlurDataset() dataloader = DataLoader(blur_dataset, batch_size=16) optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) print("len data:", dataloader.__len__()) for idx, dict in enumerate(dataloader): print("inin") input1, input2, output = dict['input1'], dict['input2'], dict['output'] sample = net(input1, input2) loss = torch.sum(torch.abs(sample - output)) optimizer.zero_grad() loss.backward() optimizer.step() print("idx-{},loss:{}".format(idx + 1, loss))
def main(): dataset_train = SurgicalDataset(data_root=args.data_root, seq_set=[1, 2, 3, 5, 6, 8], is_train=True) train_loader = DataLoader(dataset=dataset_train, batch_size=args.batch_size, shuffle=True, num_workers=2) dataset_test = SurgicalDataset(data_root=args.data_root, seq_set=[4, 7], is_train=False) test_loader = DataLoader(dataset=dataset_test, batch_size=args.batch_size, shuffle=False, num_workers=2, drop_last=True) model = ST_MTL_SEG(num_classes=args.num_classes).to(device) criterion = torch.nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=0.0001) os.makedirs(args.ckpt_dir, exist_ok=True) print('Length of dataset- train:', dataset_train.__len__(), ' valid:', test_loader.__len__()) epoch_iters = dataset_train.__len__() / args.batch_size best_dice = 0 best_epoch = 0 for epoch in range(args.num_epoch): train(train_loader, model, criterion, optimizer, epoch, epoch_iters) dices_per_class = validate(test_loader, model, args) avg_dice = dices_per_class[:4].mean( ) # First 4 classes contains in the valid set if avg_dice > best_dice: best_dice = avg_dice best_epoch = epoch torch.save( model.state_dict(), os.path.join(args.ckpt_dir, 'best_epoch_st-mtl.pth.tar')) print( 'Epoch:%d ' % epoch, 'Mean Avg Dice:%.4f [Bipolar F.:%.4f, Prograsp F.:%.4f, Large Needle D.s:%.4f, Vessel Sealer:%.4f]' % (dices_per_class[:4].mean(), dices_per_class[0], dices_per_class[1], dices_per_class[2], dices_per_class[3]), 'Best Avg Dice = %d : %.4f ' % (best_epoch, best_dice))
def word_align(args, model: PreTrainedModel, tokenizer: PreTrainedTokenizer): def collate(examples): ids_src, ids_tgt, bpe2word_map_src, bpe2word_map_tgt = zip(*examples) ids_src = pad_sequence(ids_src, batch_first=True, padding_value=tokenizer.pad_token_id) ids_tgt = pad_sequence(ids_tgt, batch_first=True, padding_value=tokenizer.pad_token_id) return ids_src, ids_tgt, bpe2word_map_src, bpe2word_map_tgt dataset = LineByLineTextDataset(tokenizer, args, file_path=args.data_file) sampler = SequentialSampler(dataset) dataloader = DataLoader(dataset, sampler=sampler, batch_size=args.batch_size, collate_fn=collate) model.to(args.device) model.eval() tqdm_iterator = trange(dataloader.__len__(), desc="Extracting") with open(args.output_file, 'w') as writer: for batch in dataloader: with torch.no_grad(): ids_src, ids_tgt, bpe2word_map_src, bpe2word_map_tgt = batch word_aligns_list = model.get_aligned_word( ids_src, ids_tgt, bpe2word_map_src, bpe2word_map_tgt, args.device, 0, 0, align_layer=args.align_layer, extraction=args.extraction, softmax_threshold=args.softmax_threshold, test=True) for word_aligns in word_aligns_list: output_str = [] for word_align in word_aligns: output_str.append(f'{word_align[0]}-{word_align[1]}') writer.write(' '.join(output_str) + '\n') tqdm_iterator.update(len(ids_src))
def _train_loop(self, labeled_loader: DataLoader = None, unlabeled_loader: DataLoader = None, epoch: int = 0, mode=ModelMode.TRAIN, *args, **kwargs): super(AdaNetTrainer, self)._train_loop(*args, **kwargs) # warnings self.model.set_mode(mode) assert self.model.training labeled_loader_ = DataIter(labeled_loader) unlabeled_loader_ = DataIter(unlabeled_loader) batch_num: tqdm = tqdm_(range(unlabeled_loader.__len__())) for _batch_num, ((label_img, label_gt), (unlabel_img, _), _) in enumerate( zip(labeled_loader_, unlabeled_loader_, batch_num)): label_img, label_gt, unlabel_img = label_img.to(self.device), \ label_gt.to(self.device), unlabel_img.to(self.device) label_pred, _ = self.model(label_img) self.METERINTERFACE.tra_conf.add(label_pred.max(1)[1], label_gt) sup_loss = self.ce_loss(label_pred, label_gt.squeeze()) self.METERINTERFACE.tra_sup_label.add(sup_loss.item()) reg_loss = self._trainer_specific_loss(label_img, label_gt, unlabel_img) self.METERINTERFACE.tra_reg_total.add(reg_loss.item()) with ZeroGradientBackwardStep(sup_loss + reg_loss, self.model) as loss: loss.backward() report_dict = self._training_report_dict batch_num.set_postfix(report_dict) print(f' Training epoch {epoch}: {nice_dict(report_dict)}')
class TrainLoader: def __init__(self, dataset_path, label_path, input_size, is_grey_scale, batch_size=64, num_workers=0, pin_memory=True): self.input_size = input_size self.batch_size = batch_size self.num_workers = num_workers self.pin_memory = pin_memory self.train_data_path = dataset_path self.train_label_path = label_path self.is_grey_scale = is_grey_scale # # Data augmentation and normalization self.train_trans = transforms.Compose([ transforms.RandomHorizontalFlip(p=0.5), transforms.RandomRotation(30), transforms.ColorJitter(), transforms.Resize(self.input_size), transforms.ToTensor(), ]) self.TrainDataLoader = DataLoader(ImageCSVLoader( self.train_trans, self.train_data_path, self.train_label_path, self.is_grey_scale), batch_size=self.batch_size, num_workers=self.num_workers, shuffle=True, pin_memory=self.pin_memory) def __len__(self): return self.TrainDataLoader.__len__()
def test(cfg, args): # torch.cuda.set_device(5) # Initialize the network model = build_detection_model(cfg) print(model) model.eval() #print(model) # model load weights model.load_state_dict(torch.load(args.model_root)) # model.load_state_dict(torch.load(cfg.MODEL.WEIGHT)) device = torch.device(cfg.MODEL.DEVICE) model.to(device) outdir = os.path.join(cfg.OUTPUT_DIR, 'inference/') if not os.path.exists(outdir): os.makedirs(outdir) # Initialize DataLoader Dataset = BatchLoader(imageRoot=args.imageroot, gtRoot=args.gtroot, reasonRoot=args.reasonroot, cropSize=(args.imHeight, args.imWidth)) dataloader = DataLoader(Dataset, batch_size=int(args.batch_size), num_workers=24, shuffle=False) AccOverallArr = [] TargetArr = [] PredArr = [] RandomArr = [] RandomF1 = [] AccOverallReasonArr = [] TargetReasonArr = [] PredReasonArr = [] RandomReasonArr = [] SaveFilename = (outdir + 'TestingLog.txt') TestingLog = open(SaveFilename, 'w') print('Save to ', SaveFilename) TestingLog.write(str(args) + '\n') count = dataloader.__len__() for i, dataBatch in enumerate(dataloader): print('Finished: {} / {}'.format(i, count)) print('Finished: %.2f%%' % (i / count * 100)) # Read data with torch.no_grad(): img_cpu = dataBatch['img'] imBatch = img_cpu.to(device) ori_img_cpu = dataBatch['ori_img'] target_cpu = dataBatch['target'] targetBatch = target_cpu.to(device) if cfg.MODEL.SIDE: reason_cpu = dataBatch['reason'] reasonBatch = reason_cpu.to(device) pred, pred_reason = model(imBatch) else: pred = model(imBatch) # Calculate accuracy predict = torch.sigmoid(pred) > 0.5 TargetArr.append(target_cpu.data.numpy()) PredArr.append(predict.cpu().data.numpy()) # print(predict) # print(target_cpu) f1_overall = f1_score(target_cpu.data.numpy(), predict.cpu().data.numpy(), average='samples') AccOverallArr.append(f1_overall) # random guess random = np.random.randint(0, 2, (predict.shape[0], predict.shape[1])) RandomArr.append(random) f1_random = f1_score(target_cpu.data.numpy(), random, average='samples') RandomF1.append(f1_random) if cfg.MODEL.SIDE: predict_reason = torch.sigmoid(pred_reason) > 0.5 TargetReasonArr.append(reason_cpu.data.numpy()) PredReasonArr.append(predict_reason.cpu().data.numpy()) f1_overall = f1_score(reason_cpu.data.numpy(), predict_reason.cpu().data.numpy(), average='samples') AccOverallReasonArr.append(f1_overall) # random guess random = np.random.randint( 0, 2, (predict_reason.shape[0], predict_reason.shape[1])) RandomReasonArr.append(random) print('prediction logits:', pred) print('prediction action: \n {}'.format(predict)) print('ground truth: \n', targetBatch.cpu().data.numpy()) print('Accumulated Overall Action acc: ', np.mean(AccOverallArr)) TestingLog.write('Iter ' + str(i) + '\n') TestingLog.write('prediction logits:' + str(pred) + '\n') TestingLog.write('prediction action: \n {}'.format(predict) + '\n') TestingLog.write('ground truth: \n' + str(targetBatch.cpu().data.numpy()) + '\n') if cfg.MODEL.SIDE: print('prediction reason: \n {}'.format(predict_reason)) print('ground truth: \n', reason_cpu.data.numpy()) print('Accumulated Overall Reason acc: ', np.mean(AccOverallReasonArr)) TestingLog.write( 'prediction reason: \n {}'.format(predict_reason) + '\n') TestingLog.write('ground truth: \n' + str(reason_cpu.data.numpy()) + '\n') TestingLog.write('\n') TargetArr = List2Arr(TargetArr) PredArr = List2Arr(PredArr) RandomArr = List2Arr(RandomArr) f1_macro, f1_micro = ComputeClsAcc(TargetArr, PredArr) print(TargetArr.shape) print(PredArr.shape) # np.save(outdir+'Target.npy', TargetArr) # np.save(outdir+'Pred.npy', PredArr) f1_pred = f1_score(TargetArr, PredArr, average=None) f1_rand = f1_score(TargetArr, RandomArr, average=None) # print("Random guess acc:{}".format(np.mean(np.array(RandomAcc),axis=0))) print("Action Random guess acc:{}".format(f1_rand)) print("Action Random guess overall acc:{}".format(np.mean(RandomF1))) print("Action Category Acc:{}".format(f1_pred)) print("Action Average Acc:{}".format(np.mean(f1_pred))) print("Action Overall acc:{}".format( np.mean(np.array(AccOverallArr), axis=0))) print("Action f1 macro Acc:{}".format(f1_macro)) print("Action mean f1 macro Acc:{}".format(np.mean(f1_macro))) print("Action f1 micro Acc:{}".format(f1_micro)) print("Action mean f1 micro Acc:{}".format(np.mean(f1_micro))) TestingLog.write("Action Random guess acc:{}".format(f1_rand)) TestingLog.write("Action Category Acc:{}".format(f1_pred)) TestingLog.write("Action Average Acc:{}".format(np.mean(f1_pred))) TestingLog.write("Action Overall acc:{}".format( np.mean(np.array(AccOverallArr), axis=0))) TestingLog.write("Action f1 macro Acc:{}".format(f1_macro)) TestingLog.write("Action mean f1 macro Acc:{}".format(np.mean(f1_macro))) TestingLog.write("Action f1 micro Acc:{}".format(f1_micro)) TestingLog.write("Action mean f1 micro Acc:{}".format(np.mean(f1_micro))) if cfg.MODEL.SIDE: TargetReasonArr = List2Arr(TargetReasonArr) PredReasonArr = List2Arr(PredReasonArr) RandomReasonArr = List2Arr(RandomReasonArr) # np.save(outdir+'TargetReason.npy', TargetReasonArr) # np.save(outdir+'PredReason.npy', PredReasonArr) f1_pred_reason = f1_score(TargetReasonArr, PredReasonArr, average=None) f1_pred_rand = f1_score(TargetReasonArr, RandomReasonArr, average=None) f1_macro, f1_micro = ComputeClsAcc(TargetReasonArr, PredReasonArr) print("Reason Random guess acc:{}".format(f1_pred_rand)) print("Reason Category Acc:{}".format(f1_pred_reason)) print("Reason Average Acc:{}".format(np.mean(f1_pred_reason))) print("Reason Overall Acc:{}".format( np.mean(np.array(AccOverallReasonArr), axis=0))) print("Reason f1 macro Acc:{}".format(f1_macro)) print("Reason mean f1 macro Acc:{}".format(np.mean(f1_macro))) print("Reason f1 micro Acc:{}".format(f1_micro)) print("Reason mean f1 micro Acc:{}".format(np.mean(f1_micro))) TestingLog.write("Reason Random guess acc:{}".format(f1_pred_rand)) TestingLog.write("Reason Category Acc:{}".format(f1_pred_reason)) TestingLog.write("Reason Average Acc:{}".format( np.mean(f1_pred_reason))) TestingLog.write("Reason Overall Acc:{}".format( np.mean(np.array(AccOverallReasonArr), axis=0))) TestingLog.write("Reason f1 macro Acc:{}".format(f1_macro)) TestingLog.write("Reason mean f1 macro Acc:{}".format( np.mean(f1_macro))) TestingLog.write("Reason f1 micro Acc:{}".format(f1_micro)) TestingLog.write("Reason mean f1 micro Acc:{}".format( np.mean(f1_micro)))
mask_im = np.dstack( [dataset_obj.get_mask().T] * 3).astype('uint8') * 255 st_im = np.dstack( [dataset_obj.get_strided_mask().T] * 3).astype('uint8') * 255 im_im = np.array(dataset_obj._slide_scaled.convert('RGB')) ov_im = mask_im / 2 + im_im / 2 ov_im_stride = st_im / 2 + im_im / 2 for key in models_to_save: imsave(ov_im.astype('uint8'), mask_im, ov_im_stride, (im_im), out=os.path.join(out_dir_dict[key], 'mask_' + out_file + '.png')) print("Total iterations: %d %d" % (dataloader.__len__(), dataloader.dataset.__len__())) for i, (data, xes, ys, label) in enumerate(dataloader): tmp_pls = lambda x: x + image_size tmp_mns = lambda x: x image_patches = data.cpu().data.numpy() image_patches = data.cpu().data.numpy() pred_map_dict = {} pred_map_dict[ensemble_key] = 0 for key in model_keys: pred_map_dict[key] = model_dict[key].predict(image_patches, verbose=0, batch_size=8) # pred_map_dict[key] = model_dict[key].predict(image_patches,verbose=0,batch_size=1) pred_map_dict[ensemble_key] += pred_map_dict[key] pred_map_dict[ensemble_key] /= len(model_keys)
def one_epoch_eval(epoch, model, summary_writer, best_acc=0, use_Normals=False): print("Evaluate Accuracy on Test After Epoch:{}".format(epoch)) valid_ds = provider.PointCloudDataSet(DATA_PATH, numOfPoints=NUM_POINT, valid=True, use_normals=use_Normals) valid_loader = DataLoader(dataset=valid_ds, batch_size=BATCH_SIZE * 2) total_seen_class = [0 for _ in range(NUM_CLASSES)] total_correct_class = [0 for _ in range(NUM_CLASSES)] running_val_loss = 0.0 total_observations = 0 correct_predeicts = 0 with torch.no_grad(): for i, data in enumerate(valid_loader, 0): inputs, labels = data['data'].to(DEVICE).float(), data['label'].to( DEVICE) if MODEL == 'pointnet_cls': # Forward main_net_output, Tnet_3x3_output, Tnet_64x64_output = model.forward( inputs) # Loss running_val_loss += model.get_model_loss( main_net_output, labels, Tnet_3x3_output, Tnet_64x64_output) elif MODEL == 'momenet_cls' or MODEL == 'momenet_with_normals': # Forward main_net_output = model.forward(inputs) # Loss running_val_loss += model.get_model_loss( main_net_output, labels) else: raise Exception("No such Model: " + MODEL) # Predict predicts = torch.argmax(main_net_output, 1) # Total Accuracy total_observations += labels.size(0) correct_predeicts += (predicts == labels).sum().item() # Mean Accuracy per class for sample_idx in range(labels.size(0)): l = labels[sample_idx] total_seen_class[l] += 1 total_correct_class[l] += (predicts[sample_idx] == l).item() val_mean_class_accuracy = np.mean( np.array(total_correct_class) / np.array(total_seen_class, dtype=np.float64)) val_accuracy = correct_predeicts / total_observations print( 'Validation Accuracy: %.4f, Validation Mean Class Accuracy: %.4f' % (val_accuracy, val_mean_class_accuracy)) summary_writer.add_scalar('Test Accuracy', val_accuracy, epoch) summary_writer.add_scalar('Test Mean Class Accuracy', val_mean_class_accuracy, epoch) summary_writer.add_scalar('Validation Mean Loss', running_val_loss / valid_loader.__len__(), epoch) # Save Best Model if best_acc < val_accuracy: best_acc = val_accuracy best_model = copy.deepcopy(model.state_dict()) torch.save(best_model, os.path.join(summary_writer.log_dir, "Best_model.pth")) return best_acc
def extract_trans_feats(model, DATASET, LABELS, CLASS_IDS, BATCH_SIZE, SEQ_SIZE=16, STEP=16, partition='train', nstrokes=-1, base_name=""): ''' Extract sequence features from AutoEncoder. Parameters: ----------- model : tt.TransformerModel TransformerModel object DATASET : str path to the video dataset LABELS : str path containing stroke labels BATCH_SIZE : int size for batch of clips SEQ_SIZE : int no. of frames in a clip STEP : int stride for next example. If SEQ_SIZE=16, STEP=8, use frames (0, 15), (8, 23) ... partition : str 'train' / 'test' / 'val' : Videos to be considered nstrokes : int partial extraction of features (do not execute for entire dataset) base_name : str path containing the pickled feature dumps Returns: -------- features_dictionary, stroke_names ''' ########################################################################### # Read the strokes # Divide the highlight dataset files into training, validation and test sets train_lst, val_lst, test_lst = autoenc_utils.split_dataset_files(DATASET) print("No. of training videos : {}".format(len(train_lst))) ##################################################################### if partition == 'train': partition_lst = train_lst ft_path = os.path.join(base_name, "C" + str(cluster_size) + "_train.pkl") elif partition == 'val': partition_lst = val_lst ft_path = os.path.join(base_name, "C" + str(cluster_size) + "_val.pkl") elif partition == 'test': partition_lst = test_lst ft_path = os.path.join(base_name, "C" + str(cluster_size) + "_test.pkl") else: print("Partition should be : train / val / test") return ########################################################################### # Create a Dataset part_dataset = StrokeFeatureSequenceDataset(ft_path, partition_lst, DATASET, LABELS, CLASS_IDS, frames_per_clip=SEQ_SIZE, extracted_frames_per_clip=2, step_between_clips=STEP, train=True) data_loader = DataLoader(dataset=part_dataset, batch_size=BATCH_SIZE, shuffle=False) ########################################################################### # Validate / Evaluate model.eval() stroke_names = [] trajectories, stroke_traj = [], [] num_strokes = 0 prev_stroke = None print("Total Batches : {} :: BATCH_SIZE : {}".format( data_loader.__len__(), BATCH_SIZE)) ########################################################################### for bno, (inputs, vid_path, stroke, labels) in enumerate(data_loader): # inputs of shape BATCH x SEQ_LEN x FEATURE_DIM inputs = inputs.float() # inp_emb = attn_utils.get_long_tensor(inputs) # comment out for SA # inputs = inp_emb.t().contiguous().to(device) # comment out for SA inputs = inputs.permute(1, 0, 2).contiguous().to(device) # forward # track history if only in train with torch.set_grad_enabled(False): outputs = model.get_vec( inputs) # output size (BATCH, SEQ_SIZE, NCLUSTERS) outputs = outputs.transpose(0, 1).contiguous() # convert to start frames and end frames from tensors to lists stroke = [s.tolist() for s in stroke] # outputs are the reconstructed features. Use compressed enc_out values(maybe wtd.). inputs_lst, batch_stroke_names = autoenc_utils.separate_stroke_tensors(outputs, \ vid_path, stroke) # for sequence of features from batch segregated extracted features. if bno == 0: prev_stroke = batch_stroke_names[0] for enc_idx, enc_input in enumerate(inputs_lst): # get no of sequences that can be extracted from enc_input tensor nSeqs = enc_input.size(0) if prev_stroke != batch_stroke_names[enc_idx]: # append old stroke to trajectories if len(stroke_traj) > 0: num_strokes += 1 trajectories.append(stroke_traj) stroke_names.append(prev_stroke) stroke_traj = [] # enc_output = model.encoder(enc_input.to(device)) # enc_output = enc_output.squeeze(axis=1).cpu().data.numpy() enc_output = enc_input.cpu().data.numpy() # convert to [[[stroke1(size 32 each) ... ], [], ...], [ [], ... ]] stroke_traj.extend([enc_output[i,j,:] for i in range(enc_output.shape[0]) \ for j in range(enc_output.shape[1])]) prev_stroke = batch_stroke_names[enc_idx] if nstrokes > -1 and num_strokes >= nstrokes: break # for last batch only if extracted for full dataset if len(stroke_traj) > 0 and nstrokes < 0: trajectories.append(stroke_traj) stroke_names.append(batch_stroke_names[-1]) # convert to dictionary of features with keys as stroke names(with ext). features = {} for i, t in enumerate(trajectories): features[stroke_names[i]] = np.array(t) # trajectories, stroke_names = autoenc_utils.group_strokewise(trajectories, stroke_names) return features, stroke_names
return self.seq_samples_db[sample_key] # In[4]: seq_len = 100 prev_poses_cnt = 5 dset = PoseMusicDataset_new(1000, seq_len, 0, prev_poses_cnt) epochs = 1000 batch_size = 10 dataloader = DataLoader(dset, batch_size=batch_size,shuffle=False, num_workers=0) print("Epochs to do:", epochs) print("Dataloader size:", dataloader.__len__()) print("Dataset size:", dset.__len__()) # In[5]: device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # Truncated backpropagation def detach(states): return [state.detach() for state in states] # In[6]:
def train(self, data_provider_path,store_learning, save_path='', restore_path='', epochs=3, dropout=0.2, display_step=100, validation_batch_size=30, prediction_path = '',dist_net=None,threshold=20,bins=15,iou_step=1,reduce_lr_steps=[1,10,100,200],data_aug=None): """ Lauches the training process :param data_provider_path: where the DATASET folder is :param store_learning: to store the metrics during the training as .txt file :param save_path: path where to store checkpoints :param restore_path: path where is the model to restore is stored :param epochs: number of epochs :param dropout: dropout probability :param validation_batch_size: batch size of the validation set :param prediction_path: where to store output of training (patches, losses .txt file, models) :param dist_net: distance module or not :param threshold: threshold of distance module :param bins: number of bins for distance module :iou_step: how often is computed Iou measures over the validation set :reduce_lr_steps: epoch at which the learning rate is halved :data_aug: 'yes' or 'no' if the training set is augmented """ ##SET UP PATHS FOR TRAINING ## #check they exist? PATH_TRAINING=data_provider_path+'TRAINING/' if not os.path.exists(PATH_TRAINING): print('Training dataset path not valid. Should be path_to_dataset/TRAINING/ and this folder should contain INTPUT/ and OUTPUT/') raise PATH_VALIDATION=data_provider_path+'VALIDATION/' if not os.path.exists(PATH_VALIDATION): print('Validation dataset path not valid. Should be path_to_dataset/VALIDATION/ and this folder should contain INTPUT/ and OUTPUT/') raise PATH_TEST=data_provider_path+'TEST/' if not os.path.exists(PATH_TEST): print('Test dataset path not valid. Should be path_to_dataset/TEST/ and this folder should contain INTPUT/ and OUTPUT/') raise TMP_IOU=prediction_path+'TMP_IOU/' if not os.path.exists(TMP_IOU): os.makedirs(TMP_IOU) loss_train=[] if epochs == 0: print('Epoch set 0, model won\'t be trained') raise if save_path=='': print('Specify a path where to store the Model') raise if prediction_path=='': print('Specify where to stored visualization of training') raise if restore_path=='': store_learning.initialize('w') store_learning print('Model trained from scratch') else: store_learning.initialize('a') self.net.load_state_dict(torch.load(restore_path)) print('Model loaded from {}'.format(restore_path)) self._initialize(prediction_path,store_learning,iou_step,dist_net,threshold,bins) ###Validation loader val_generator=Dataset_sat.from_root_folder(PATH_VALIDATION,self.nb_classes) val_loader = DataLoader(val_generator, batch_size=validation_batch_size,shuffle=False, num_workers=1) RBD=randint(0,int(val_loader.__len__())-1) self.info_validation(val_loader,-1,RBD,"_init",TMP_IOU) ###Training loader train_generator=Dataset_sat.from_root_folder(PATH_TRAINING,self.nb_classes,transform=data_aug)#max_data_size=4958 logging.info("Start optimization") counter=0 for epoch in range(epochs): ##tune learning reate if epoch in reduce_lr_steps: self.lr = self.lr * 0.5 self.optimizer = torch.optim.Adam(self.net.parameters(), lr=self.lr) total_loss = 0 error_tot=0 train_loader = DataLoader(train_generator, batch_size=self.batch_size,shuffle=True, num_workers=1) for i_batch,sample_batch in enumerate(train_loader): self.optimizer.zero_grad() predict_net=Train_or_Predict(sample_batch,self.dist_net,self.loss_fn,self.threshold,self.bins,self.net) loss,_,probs_seg=predict_net.forward_pass() loss,self.optimizer,self.net=predict_net.backward_prog(loss,self.optimizer) total_loss+=loss.data[0] loss_train.append(loss.data[0]) counter+=1 if i_batch % display_step == 0: self.output_training_stats(i_batch,loss,predict_net.batch_y,probs_seg) avg_loss_train_value=total_loss/train_loader.__len__() (self.store_learning).avg_loss_train.append(avg_loss_train_value) (self.store_learning).write_file((self.store_learning).file_train,avg_loss_train_value) logging.info(" Training {:}, Minibatch Loss= {:.4f}".format("epoch_%s"%epoch,avg_loss_train_value)) self.info_validation(val_loader,epoch,RBD,"epoch_%s"%epoch,TMP_IOU) torch.save(self.net.state_dict(),save_path + 'CP{}.pth'.format(epoch)) print('Checkpoint {} saved !'.format(epoch)) self.info_validation(val_loader,-2,RBD,'_last_',TMP_IOU) # time.sleep(4) # plt.close(fig) return save_path + 'CP{}.pth'.format(epoch)