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)
