def eval(cfg):
# Setup seeds
torch.manual_seed(cfg.get("seed", 1337))
torch.cuda.manual_seed(cfg.get("seed", 1337))
np.random.seed(cfg.get("seed", 1337))
random.seed(cfg.get("seed", 1337))
# Setup device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# Setup evaluation data
loader_source = get_loader(cfg, "train")
# data_eval_labels = utils.recursive_glob(os.path.join(cfg["data"]["path"], 'labels'))
# Setup model
model = Unet(cfg).to(device)
checkpoint = torch.load(cfg["training"]["checkpoint"])
model.load_state_dict(checkpoint["model_state"])
stats = None
model.eval()
for images, labels in tqdm.tqdm(loader_source):
model.set_input(images, labels)
model.forward()
if stats is None:
stats = [StatsRecorder() for i in range(len(model.hooks))]
for i, hook in enumerate(model.hooks):
activation = hook.output
b, c, h, w = activation.shape
activation = activation.transpose(0,
1).reshape(c,
-1).transpose(0, 1)
stats[i].update(activation.cpu().data.numpy())
print([s.mean for s in stats])
print([s.std for s in stats])
def main(args):
device = 'cuda' if torch.cuda.is_available() else 'cpu'
d = dcrf.DenseCRF2D(512, 512, 2)
down_method = args.down_method
up_method = args.up_method
separable = args.separable
ds = DataSetWrapper(args.batch_size, args.num_workers, 0.2)
test_dl = ds.get_data_loaders(train=False)
model = Unet(input_dim=1,
separable=True,
down_method='conv',
up_method='transpose')
model = nn.DataParallel(model).to(device)
load_state = torch.load(f'./checkpoint/conv_transpose_True.ckpt')
model.load_state_dict(load_state['model_state_dict'])
model.eval()
name = 0
with torch.no_grad():
for (img, label) in test_dl:
imgs, labels = img.to(device), label.to(device)
preds = model(img)
name += 1
for i in range(args.batch_size):
img, label, pred = imgs[i, :], labels[i, :], preds[i, :]
probs = torch.stack([1 - pred, pred], dim=0).cpu().numpy()
img, label = img.cpu().numpy(), label.cpu().numpy()
pairwise_energy = create_pairwise_bilateral(sdims=(10, 10),
schan=(0.01, ),
img=img,
chdim=0)
U = unary_from_softmax(probs)
d = dcrf.DenseCRF2D(512, 512, 2)
d.setUnaryEnergy(U)
d.addPairwiseEnergy(pairwise_energy, compat=10)
Q = d.inference(100)
map = np.argmax(Q, axis=0).reshape((512, 512))
print(map.shape)
img = (255. / img.max() * (img - img.min())).astype(np.uint8)
label = (255. / label.max() * (label - label.min())).astype(
np.uint8)
pred = (255. / map.max() * (map - map.min())).astype(np.uint8)
img = Image.fromarray(img[0, :], mode='L')
label = Image.fromarray(label[0, :], mode='L')
pred = Image.fromarray(pred, mode='L')
img.save(f'./results/{name}_{i}_i.png')
label.save(f'./results/{name}_{i}_l.png')
pred.save(f'./results/{name}_{i}_p.png')
def main(args):
device = 'cuda' if torch.cuda.is_available() else 'cpu'
separable = args.separable
up_method = args.up_method
down_method = args.down_method
img_src = args.s
######## Model Setting ########
model = Unet(input_dim=1,
separable=separable,
down_method=down_method,
up_method=up_method)
model = nn.DataParallel(model).to(device)
load_state = torch.load(
f'./checkpoint/{down_method}_{up_method}_{separable}.ckpt')
model.load_state_dict(load_state['model_state_dict'])
model.eval()
###############################
d = dcrf.DenseCRF2D(512, 512, 2)
img = Image.open(img_src).convert('L')
img = pad_resize(img, 512)
img = TF.to_tensor(img)
img = img.unsqueeze(0)
with torch.no_grad():
img = img.to(device)
pred = model(img)
probs = torch.stack([1 - pred, pred], dim=0).cpu().numpy()
img, pred = img.cpu().numpy(), pred.cpu().numpy()
pairwise_energy = create_pairwise_bilateral(sdims=(10, 10),
schan=(0.01, ),
img=img,
chdim=0)
U = unary_from_softmax(probs)
d.setUnaryEnergy(U)
d.addPairwiseEnergy(pairwise_energy, compat=10)
Q = d.inference(100)
map = np.argmax(Q, axis=0).reshape((512, 512))
img = (255. / img.max() * (img - img.min())).astype(np.uint8)
pred = (255. / map.max() * (map - map.min())).astype(np.uint8)
img = Image.fromarray(np.squeeze(img), mode='L')
pred = Image.fromarray(pred, mode='L')
img.save(f'../similarity/{img_src[:-4]}_o.png')
pred.save(f'../similarity/{img_src[:-4]}_p.png')
def train():
save_dir = "/home/FuDawei/NLP/SQUAD/unet/data/"
train_examples, dev_examples, opt = prepare_train(save_dir)
epoch = 30
batch_size = 32
model = Unet(opt=opt).to(device)
parameters = filter(lambda p: p.requires_grad, model.parameters())
optimizer = torch.optim.Adamax(parameters, lr=opt["lr"])
best_score, exact_scores, f1_scores = 0, [], []
count = 0
total_loss = 0
for ep in range(epoch):
model.train()
for batch_data in get_batch_data(train_examples, batch_size):
data = model.get_data(batch_data)
loss = model(data)
model.zero_grad()
optimizer.zero_grad()
loss.backward()
nn.utils.clip_grad_norm_(parameters, 10)
optimizer.step()
model.reset_parameters()
count += 1
# print(loss.item())
# Evaluate(dev_examples, model)
total_loss += loss.item()
if count % 100 == 0:
print(total_loss / 100)
total_loss = 0
# model.eval()
# Evaluate(dev_examples, model, opt)
if not opt["fix_word_embedding"]:
model.reset_parameters()
print(ep)
model.eval()
exact, f1 = Evaluate(dev_examples, model, opt)
exact_scores.append(exact)
f1_scores.append(f1)
if f1 > best_score:
best_score = f1
torch.save(model.state_dict(), save_dir + "best_model")
with open(save_dir + '_f1_scores.pkl', 'wb') as f:
pkl.dump(f1_scores, f)
with open(save_dir + '_exact_scores.pkl', 'wb') as f:
pkl.dump(exact_scores, f)
def test(args):
my_dataset = MyDataset("../data/val", transform=x_transforms, target_transform=y_transforms)
dataloaders = DataLoader(my_dataset, batch_size=1)
model = Unet(3, 1)
model.load_state_dict(torch.load(args.model_path, map_location='cpu'))
model.eval()
plt.ion()
with torch.no_grad():
count = 0
for x, _ in dataloaders:
y = model(x)
img_y = torch.squeeze(y).numpy()
predict_path = os.path.join("../data/predict/", "%03d_predict.png" % count)
plt.imsave(predict_path, img_y)
plt.imshow(img_y)
plt.pause(0.1)
count += 1
plt.show()
std = (0.229, 0.224, 0.225)
df = pd.read_csv(sample_submission_path)
testset = DataLoader(
TestDataset(test_data_folder, df, mean, std),
batch_size=batch_size,
shuffle=False,
num_workers=num_workers,
pin_memory=True
)
# Initialize mode and load trained weights
ckpt_path = "../input/res18ex6/model26.pth"
device = torch.device("cuda")
model = Unet("resnet18", encoder_weights=None, classes=4, activation=None)
model.to(device)
model.eval()
state = torch.load(ckpt_path, map_location=lambda storage, loc: storage)
model.load_state_dict(state["state_dict"])
# start prediction
predictions = []
for i, batch in enumerate(tqdm(testset)):
fnames, images = batch
batch_preds = torch.sigmoid(model(images.to(device)))
batch_preds = batch_preds.detach().cpu().numpy()
for fname, preds in zip(fnames, batch_preds):
for cls, pred in enumerate(preds):
pred, num = post_process(pred, best_threshold, min_size)
rle = mask2rle(pred)
name = fname + f"_{cls+1}"
predictions.append([name, rle])
validation_augmentation_kaggle())
test_loader = DataLoader(test_set, batch_size=batch_size, shuffle=False)
print('testing data loaded')
net = Unet(3, 4).float()
if is_gpu:
net.cuda()
net.load_state_dict(torch.load(model_id, map_location=device))
print('model loaded')
# prepare
ans_dict = global_dict()
image_uid = 0
answer_label = []
answer_index = ['Image_Label', 'EncodedPixels']
# calculation
t_bar = tq(test_loader)
net.eval()
with torch.no_grad():
for img, masks in t_bar:
if is_gpu:
img = img.cuda()
masks_pr = net(img).cpu().detach().numpy()
for batch in masks_pr:
for i, mask in enumerate(batch):
# image_uid, i
answer_label.append(get_answer(mask, thresholds[i]))
image_uid += 1
# submission
submit_file = model_id + '.csv'
sub = test_set.df
sub['EncodedPixels'] = answer_label
sub.to_csv(submit_file, columns=answer_index, index=False)
def main(args):
device = 'cuda' if torch.cuda.is_available() else 'cpu'
### Hyperparameters Setting ###
epochs = args.epochs
batch_size = args.batch_size
num_workers = args.num_workers
valid_ratio = args.valid_ratio
threshold = args.threshold
separable = args.separable
down_method = args.down_method
up_method = args.up_method
### DataLoader ###
dataset = DataSetWrapper(batch_size, num_workers, valid_ratio)
train_dl, valid_dl = dataset.get_data_loaders(train=True)
### Model: U-Net ###
model = Unet(input_dim=1,
separable=separable,
down_method=down_method,
up_method=up_method)
model.summary()
model = nn.DataParallel(model).to(device)
optimizer = optim.Adam(model.parameters(),
lr=args.lr,
weight_decay=args.weight_decay)
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer,
T_max=len(train_dl),
eta_min=0,
last_epoch=-1)
criterion = nn.BCEWithLogitsLoss()
train_losses = []
val_losses = []
###Train & Validation start ###
mIOU_list = []
best_mIOU = 0.
step = 0
for epoch in range(epochs):
### train ###
pbar = tqdm(train_dl)
model.train()
losses = []
for (img, label) in pbar:
optimizer.zero_grad()
img, label = img.to(device), label.to(device)
pred = model(img)
# pred = Padding()(pred, label.size(3))
loss = criterion(pred, label)
loss.backward()
optimizer.step()
losses.append(loss.item())
pbar.set_description(
f'E: {epoch + 1} | L: {loss.item():.4f} | lr: {scheduler.get_lr()[0]:.7f}'
)
scheduler.step()
if (epoch + 1) % 10:
losses = sum(losses) / len(losses)
train_losses.append(losses)
### validation ###
with torch.no_grad():
model.eval()
mIOU = []
losses = []
pbar = tqdm(valid_dl)
for (img, label) in pbar:
img, label = img.to(device), label.to(device)
pred = model(img)
loss = criterion(pred, label)
mIOU.append(get_IOU(pred, label, threshold=threshold))
losses.append(loss.item())
mIOU = sum(mIOU) / len(mIOU)
mIOU_list.append(mIOU)
if (epoch + 1) % 10:
losses = sum(losses) / len(losses)
val_losses.append(losses)
print(
f'VL: {loss.item():.4f} | mIOU: {100 * mIOU:.1f}% | best mIOU: {100 * best_mIOU:.1f}'
)
### Early Stopping ###
if mIOU > best_mIOU:
best_mIOU = mIOU
save_state = {
'epoch': epoch,
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'scheduler_state_dict': scheduler.state_dict(),
'train_losses': train_losses,
'val_losses': val_losses,
'best_mIOU': best_mIOU
}
torch.save(
save_state,
f'./checkpoint/{down_method}_{up_method}_{separable}.ckpt')
step = 0
else:
step += 1
if step > args.patience:
print('Early stopped...')
return
def train(args, x_train, y_train, x_valid, y_valid):
writer = SummaryWriter()
best_dice = 0
model = Unet().to(args.device)
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
bce_loss = torch.nn.BCELoss()
train_dataloader = load_dataset(x_train, y_train, args.batch_size, True)
valid_dataloader = load_dataset(x_valid, y_valid, args.batch_size, False)
result = {}
result['train/BCE'] = []
result['train/Dice'] = []
result['valid/BCE'] = []
result['valid/Dice'] = []
for epoch in range(args.epochs):
print('train step: epoch {}'.format(str(epoch+1).zfill(4)))
train_bce = []
train_dice = []
for inp_im, lab_im in tqdm(train_dataloader):
inp_im = inp_im.to(args.device)
lab_im = lab_im.to(args.device)
pred = model(inp_im)
bce = bce_loss(pred, lab_im)
dice = calc_dice(pred, lab_im)
train_bce.append(bce.item())
train_dice.append(dice)
model.zero_grad()
bce.backward()
optimizer.step()
result['train/BCE'].append(statistics.mean(train_bce))
result['train/Dice'].append(statistics.mean(train_dice))
writer.add_scalar('train/BinaryCrossEntropy', result['train/BCE'][-1], epoch+1)
writer.add_scalar('train/DiceScore', result['train/Dice'][-1], epoch+1)
print('BCE: {}, Dice: {}'.format(result['train/BCE'][-1], result['train/Dice'][-1]))
if (epoch+1) % 10 == 0 or (epoch+1) == 1:
with torch.no_grad():
print('valid step: epoch {}'.format(str(epoch+1).zfill(4)))
model.eval()
valid_bce = []
valid_dice = []
for inp_im, lab_im in tqdm(valid_dataloader):
inp_im = inp_im.to(args.device)
lab_im = lab_im.to(args.device)
pred = model(inp_im)
bce = bce_loss(pred, lab_im)
dice = calc_dice(pred, lab_im)
valid_bce.append(bce.item())
valid_dice.append(dice)
result['valid/BCE'].append(statistics.mean(valid_bce))
result['valid/Dice'].append(statistics.mean(valid_dice))
writer.add_scalar('valid/BinaryCrossEntropy', result['valid/BCE'][-1], epoch+1)
writer.add_scalar('valid/DiceScore', result['valid/Dice'][-1], epoch+1)
print('BCE: {}, Dice: {}'.format(result['valid/BCE'][-1], result['valid/Dice'][-1]))
if best_dice < result['valid/Dice'][-1]:
best_dice = result['valid/Dice'][-1]
best_model_name = os.path.join(args.save_model_path, f'best_model_{epoch + 1:04}.pth')
print('save model ==>> {}'.format(best_model_name))
torch.save(model.state_dict(), best_model_name)
