def evaluate(self, val_loader):
self.model = self.model.eval()
with torch.no_grad():
bar_steps = len(val_loader)
nums = torch.tensor([0 for i in range(self.num_classes-1)]).to(self.device)
dens = torch.tensor([0 for i in range(self.num_classes-1)]).to(self.device)
for data in val_loader:
inputs, labels = data
inputs, labels = inputs.to(self.device), labels.to(self.device)
outputs = self.model(inputs)
preds_np=outputs.detach()
labels_np = labels.detach()
num, den = compute_iou_batch(preds_np, labels_np, self.device, self.num_classes)
nums += num
dens += den
print(nums, dens)
ious = nums*1.0 / dens
print(ious)
iou=torch.mean(ious).item()
print('iou:{:.4f} '.format(iou))
#Validation
valid_losses = []
valid_ious = []
model.eval()
with torch.no_grad():
with tqdm(valid_loader) as _tqdm:
for batched in _tqdm:
images, labels = batched
if fp16:
images = images.half()
images, labels = images.to(device), labels.to(device)
preds = model.tta(images, net_type=net_type)
if fp16:
loss = loss_fn(preds.float(), labels)
else:
loss = loss_fn(preds, labels)
preds_np = preds.detach().cpu().numpy()
labels_np = labels.detach().cpu().numpy()
iou = compute_iou_batch(np.argmax(preds_np, axis=1), labels_np,
classes)
_tqdm.set_postfix(
OrderedDict(seg_loss=f'{loss.item():.5f}', iou=f'{iou:.3f}'))
valid_losses.append(loss.item())
valid_ious.append(iou)
valid_loss = np.mean(valid_losses)
valid_iou = np.nanmean(valid_ious)
logger.info(f'valid seg loss: {valid_loss}')
logger.info(f'valid iou: {valid_iou}')
def train(self, train_loader, val_loader, loss_function, num_epochs):
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
dataloaders = {'train': train_loader, 'val': val_loader}
writer = SummaryWriter(log_dir=self.log_dir)
self.model = self.model.to(device)
for epoch in range(self.epoch, num_epochs):
since = time.time()
print('Epoch {}/{}'.format(epoch, num_epochs - 1))
for phase in ['train', 'val']:
if phase == 'train':
self.model.train()
else:
self.model.eval()
running_loss = 0.0
bar_steps = len(dataloaders[phase])
process_bar = ShowProcess(bar_steps)
total = 0
ious = []
#########################################################
#
#########################################################
for i, data in enumerate(dataloaders[phase], 0):
inputs, labels = data
inputs, labels = inputs.to(device), labels.to(device)
self.optim.zero_grad()
# forward
# track history if only in train
with torch.set_grad_enabled(phase == 'train'):
outputs = self.model(inputs)
loss = loss_function(outputs, labels)
# preds = F.interpolate(outputs[0], size=labels.size()[2:], mode='bilinear', align_corners=True)
preds_np = outputs.detach().cpu().numpy()
labels_np = labels.detach().cpu().numpy().squeeze()
iou = compute_iou_batch(preds_np, labels_np)
ious.append(iou)
# backward+optimize only if in training phase
if phase == 'train':
loss.backward()
self.optim.step()
if self.scheduler:
# self.scheduler.step(loss.cpu().data.numpy())
self.scheduler.step()
# statistics
total += inputs.size(0)
running_loss += loss.item() * inputs.size(0)
process_bar.show_process()
process_bar.close()
epoch_loss = running_loss / total
iou = np.mean(ious)
print('{} Loss: {:.4f} iou:{:.4f} '.format(
phase, epoch_loss, iou))
writer.add_scalar('{}_loss'.format(phase), epoch_loss, epoch)
writer.add_scalar('{}_iou'.format(phase), iou, epoch)
time_elapsed = time.time() - since
print('one epoch complete in {:.0f}m {:.0f}s'.format(
time_elapsed // 60, time_elapsed % 60))
##############################################################
# save the model for every epoch #
##############################################################
torch.save(
{
'epoch': epoch,
'model_state_dict': self.model.state_dict(),
'optimizer_state_dict': self.optim.state_dict(),
'lr_scheduler': self.scheduler.state_dict(),
'loss': loss
}, self.checkpoint_path.format(epoch))
writer.close()
print("train finished")
images, labels, _ = batched
if fp16:
images = images.half()
images, labels = images.to(device), labels.to(device)
optimizer.zero_grad()
preds = model(images)
if net_type == 'deeplab':
preds = F.interpolate(preds,
size=labels.shape[1:],
mode='bilinear',
align_corners=True)
loss = loss_fn(preds, labels)
preds_np = preds.detach().cpu().numpy()
labels_np = labels.detach().cpu().numpy()
iou = compute_iou_batch(np.argmax(preds_np, axis=1), labels_np,
classes[1 if include_bg else 0:])
_tqdm.set_postfix(
OrderedDict(seg_loss=f'{loss.item():.5f}',
iou=f'{iou:.3f}'))
train_losses.append(loss.item())
train_ious.append(iou)
if fp16:
with amp.scale_loss(loss, optimizer) as scaled_loss:
scaled_loss.backward()
else:
loss.backward()
optimizer.step()
scheduler.step()
size=labels_sidewalk.shape[1:],
mode='bilinear',
align_corners=True)
# if fp16:
# loss = loss_fn(preds.float(), labels)
# else:
# loss = loss_fn(preds, labels)
loss1 = loss_fn(mask1, labels_sidewalk)
loss2 = loss_fn(mask2, labels_defects)
loss3 = loss_fn(mask3, labels_maj_defects)
loss = loss1 + 10 * loss3
mask1_np = mask1.detach().cpu().numpy()
labels_sidewalk_np = labels_sidewalk.detach().cpu().numpy()
iou1 = compute_iou_batch(np.argmax(mask1_np, axis=1),
labels_sidewalk_np, classes)
mask2_np = mask2.detach().cpu().numpy()
labels_defects_np = labels_defects.detach().cpu().numpy()
iou2 = compute_iou_batch(np.argmax(mask2_np, axis=1),
labels_defects_np, classes)
mask3_np = mask3.detach().cpu().numpy()
labels_maj_defects_np = labels_maj_defects.detach().cpu().numpy()
iou3 = compute_iou_batch(np.argmax(mask3_np, axis=1),
labels_maj_defects_np, classes)
iou = np.nanmean([iou1, iou2, iou3])
_tqdm.set_postfix(
OrderedDict(seg_loss1=f'{loss1.item():.5f}',
def train():
best_metrics = 0
loss_history = []
iou_history = []
if resume:
model_path = output_dir.joinpath(f'model.pth')
logger.info(f'Resume from {model_path}')
param = torch.load(model_path)
model.load_state_dict(param)
del param
for _ in range(start_epoch):
scheduler.step()
if log_dir.joinpath('history.pkl').exists():
with open(log_dir.joinpath('history.pkl'), 'rb') as f:
history_dict = pickle.load(f)
best_metrics = history_dict['best_metrics']
loss_history = history_dict['seg_loss']
iou_history = history_dict['iou']
for i_epoch in range(start_epoch, max_epoch):
logger.info(f'Epoch: {i_epoch}')
logger.info(f'Learning rate: {optimizer.param_groups[0]["lr"]}')
train_losses = []
train_ious = []
with tqdm(train_loader) as _tqdm:
for batched in _tqdm:
images, labels = batched
images, labels = images.to(device), labels.to(device)
optimizer.zero_grad()
preds = model(images)
preds = F.interpolate(preds,
size=labels.shape[2:],
mode='bilinear',
align_corners=True)
loss = loss_fn(preds, labels)
preds_np = preds.detach().cpu().numpy()
labels_np = labels.detach().cpu().numpy().squeeze()
iou = compute_iou_batch(preds_np, labels_np)
_tqdm.set_postfix(
OrderedDict(seg_loss=f'{loss.item():.5f}',
iou=f'{iou:.3f}'))
train_losses.append(loss.item())
train_ious.append(iou)
loss.backward()
optimizer.step()
scheduler.step()
train_loss = np.mean(train_losses)
train_iou = np.mean(train_ious)
logger.info(f'train loss: {train_loss}')
logger.info(f'train iou: {train_iou}')
valid_losses = []
valid_ious = []
model.eval()
with torch.no_grad():
with tqdm(valid_loader) as _tqdm:
for batched in _tqdm:
images, labels = batched
images, labels = images.to(device), labels.to(device)
preds = model(images)
preds = F.interpolate(preds,
size=labels.shape[2:],
mode='bilinear',
align_corners=True)
loss = loss_fn(preds, labels)
preds_np = preds.detach().cpu().numpy()
labels_np = labels.detach().cpu().numpy()
iou = compute_iou_batch(preds_np, labels_np)
_tqdm.set_postfix(
OrderedDict(seg_loss=f'{loss.item():.5f}',
iou=f'{iou:.3f}'))
valid_losses.append(loss.item())
valid_ious.append(iou)
model.train()
valid_loss = np.mean(valid_losses)
valid_iou = np.mean(valid_ious)
logger.info(f'valid seg loss: {valid_loss}')
logger.info(f'valid iou: {valid_iou}')
loss_history.append([train_loss, valid_loss])
iou_history.append([train_iou, valid_iou])
history_ploter(loss_history, log_dir.joinpath('loss.png'))
history_ploter(iou_history, log_dir.joinpath('iou.png'))
torch.save(model.state_dict(), output_dir.joinpath('model_tmp.pth'))
if best_metrics < valid_iou:
best_metrics = valid_iou
logger.info('Best Model!')
torch.save(model.state_dict(), output_dir.joinpath('model.pth'))
history_dict = {
'loss': loss_history,
'iou': iou_history,
'best_metrics': best_metrics
}
with open(log_dir.joinpath('history.pkl'), 'wb') as f:
pickle.dump(history_dict, f)
def train(self, train_loader, val_loader, loss_function1, loss_function2, num_epochs):
dataloaders = {'train': train_loader, 'val': val_loader}
writer = SummaryWriter(log_dir=self.log_dir)
for epoch in range(self.epoch, num_epochs):
since = time.time()
print('Epoch {}/{}'.format(epoch, num_epochs - 1))
for phase in ['train', 'val']:
if phase == 'train':
self.model.train()
print("lr: ", self.optim.param_groups[0]['lr'])
else:
self.model.eval()
running_loss = 0.0
bar_steps = len(dataloaders[phase])
#process_bar = ShowProcess(bar_steps)
total = 0
nums = torch.tensor([0 for i in range(self.num_classes-1)]).to(self.device)
dens = torch.tensor([0 for i in range(self.num_classes-1)]).to(self.device)
for i, data in enumerate(dataloaders[phase], 0):
inputs, labels = data
inputs, labels = inputs.to(self.device), labels.to(self.device)
self.optim.zero_grad()
#forward
#track history if only in train
with torch.set_grad_enabled(phase == 'train'):
outputs = self.model.forward(inputs, only_encode=self.config.only_encode)
loss = loss_function1(outputs, labels) + self.gamma * loss_function2(outputs, labels)
#preds = F.interpolate(outputs[0], size=labels.size()[2:], mode='bilinear', align_corners=True)
preds_np=outputs.detach()
labels_np = labels.detach()
num, den = compute_iou_batch(preds_np, labels_np, self.device, self.num_classes)
nums += num
dens += den
if phase == 'train':
loss.backward()
self.optim.step()
total += inputs.size(0)
running_loss += loss.item() * inputs.size(0)
if phase == 'train':
#self.scheduler.step(loss.cpu().data.numpy())
if self.scheduler:
self.scheduler.step()
epoch_loss = running_loss / total
ious = nums*1.0 / dens
iou=torch.mean(ious).item()
print('{} Loss: {:.4f} iou:{:.4f} '.format(phase, epoch_loss,iou))
writer.add_scalar('{}_loss'.format(phase), epoch_loss, epoch)
writer.add_scalar('{}_iou'.format(phase),iou,epoch)
time_elapsed = time.time() - since
print('one epoch complete in {:.0f}m {:.0f}s'.format(
time_elapsed // 60, time_elapsed % 60))
if self.config.only_encode:
torch.save({
'epoch': epoch,
'model_state_dict': self.model.module.encoder.state_dict(),
'optimizer_state_dict': self.optim.state_dict(),
'lr_scheduler': self.scheduler.state_dict(),
'loss': loss
}, self.checkpoint_path.format(epoch))
else:
torch.save({
'epoch': epoch,
'model_state_dict': self.model.module.state_dict(),
'optimizer_state_dict': self.optim.state_dict(),
'lr_scheduler': self.scheduler.state_dict(),
'loss': loss
}, self.checkpoint_path.format(epoch))
writer.close()
print("train finished")
def process(config_path):
gc.collect()
torch.cuda.empty_cache()
config = yaml.load(open(config_path))
net_config = config['Net']
data_config = config['Data']
train_config = config['Train']
loss_config = config['Loss']
opt_config = config['Optimizer']
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
t_max = opt_config['t_max']
# Collect training parameters
max_epoch = train_config['max_epoch']
batch_size = train_config['batch_size']
fp16 = train_config['fp16']
resume = train_config['resume']
pretrained_path = train_config['pretrained_path']
freeze_enabled = train_config['freeze']
seed_enabled = train_config['seed']
#########################################
# Deterministic training
if seed_enabled:
seed = 100
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
np.random.seed(seed=seed)
import random
random.seed(a=100)
#########################################
# Network
if 'unet' in net_config['dec_type']:
net_type = 'unet'
model = EncoderDecoderNet(**net_config)
else:
net_type = 'deeplab'
net_config['output_channels'] = 19
model = SPPNet(**net_config)
dataset = data_config['dataset']
if dataset == 'deepglobe-dynamic':
from dataset.deepglobe_dynamic import DeepGlobeDatasetDynamic as Dataset
net_config['output_channels'] = 7
classes = np.arange(0, 7)
else:
raise NotImplementedError
del data_config['dataset']
modelname = config_path.stem
timestamp = datetime.timestamp(datetime.now())
print("timestamp =", datetime.fromtimestamp(timestamp))
output_dir = Path(os.path.join(ROOT_DIR, f'model/{modelname}_{datetime.fromtimestamp(timestamp)}') )
output_dir.mkdir(exist_ok=True)
log_dir = Path(os.path.join(ROOT_DIR, f'logs/{modelname}_{datetime.fromtimestamp(timestamp)}') )
log_dir.mkdir(exist_ok=True)
dataset_dir= '/home/sfoucher/DEV/pytorch-segmentation/data/deepglobe_as_pascalvoc/VOCdevkit/VOC2012'
logger = debug_logger(log_dir)
logger.debug(config)
logger.info(f'Device: {device}')
logger.info(f'Max Epoch: {max_epoch}')
# Loss
loss_fn = MultiClassCriterion(**loss_config).to(device)
params = model.parameters()
optimizer, scheduler = create_optimizer(params, **opt_config)
# history
if resume:
with open(log_dir.joinpath('history.pkl'), 'rb') as f:
history_dict = pickle.load(f)
best_metrics = history_dict['best_metrics']
loss_history = history_dict['loss']
iou_history = history_dict['iou']
start_epoch = len(iou_history)
for _ in range(start_epoch):
scheduler.step()
else:
start_epoch = 0
best_metrics = 0
loss_history = []
iou_history = []
affine_augmenter = albu.Compose([albu.HorizontalFlip(p=.5),albu.VerticalFlip(p=.5)
# Rotate(5, p=.5)
])
# image_augmenter = albu.Compose([albu.GaussNoise(p=.5),
# albu.RandomBrightnessContrast(p=.5)])
image_augmenter = None
# This has been put in the loop for the dynamic training
"""
# Dataset
train_dataset = Dataset(affine_augmenter=affine_augmenter, image_augmenter=image_augmenter,
net_type=net_type, **data_config)
valid_dataset = Dataset(split='valid', net_type=net_type, **data_config)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=4,
pin_memory=True, drop_last=True)
valid_loader = DataLoader(valid_dataset, batch_size=1, shuffle=False, num_workers=4, pin_memory=True)
"""
# Pretrained model
if pretrained_path:
logger.info(f'Resume from {pretrained_path}')
param = torch.load(pretrained_path)
model.load_state_dict(param)
model.logits = torch.nn.Conv2d(256, net_config['output_channels'], 1)
del param
# To device
model = model.to(device)
#########################################
if freeze_enabled:
# Code de Rémi
# Freeze layers
for param_index in range(int((len(optimizer.param_groups[0]['params']))*0.5)):
optimizer.param_groups[0]['params'][param_index].requires_grad = False
#########################################
params_to_update = model.parameters()
print("Params to learn:")
if freeze_enabled:
params_to_update = []
for name,param in model.named_parameters():
if param.requires_grad == True:
params_to_update.append(param)
print("\t",name)
optimizer, scheduler = create_optimizer(params_to_update, **opt_config)
# fp16
if fp16:
# I only took the necessary files because I don't need the C backend of apex,
# which is broken and can't be installed
# from apex import fp16_utils
from utils.apex.apex.fp16_utils.fp16util import BN_convert_float
from utils.apex.apex.fp16_utils.fp16_optimizer import FP16_Optimizer
# model = fp16_utils.BN_convert_float(model.half())
model = BN_convert_float(model.half())
# optimizer = fp16_utils.FP16_Optimizer(optimizer, verbose=False, dynamic_loss_scale=True)
optimizer = FP16_Optimizer(optimizer, verbose=False, dynamic_loss_scale=True)
logger.info('Apply fp16')
# Restore model
if resume:
model_path = output_dir.joinpath(f'model_tmp.pth')
logger.info(f'Resume from {model_path}')
param = torch.load(model_path)
model.load_state_dict(param)
del param
opt_path = output_dir.joinpath(f'opt_tmp.pth')
param = torch.load(opt_path)
optimizer.load_state_dict(param)
del param
i_iter = 0
ma_loss= 0
ma_iou= 0
# Train
for i_epoch in range(start_epoch, max_epoch):
logger.info(f'Epoch: {i_epoch}')
logger.info(f'Learning rate: {optimizer.param_groups[0]["lr"]}')
train_losses = []
train_ious = []
model.train()
# Initialize randomized but balanced datasets
train_dataset = Dataset(base_dir = dataset_dir,
affine_augmenter=affine_augmenter, image_augmenter=image_augmenter,
net_type=net_type, **data_config)
valid_dataset = Dataset(base_dir = dataset_dir,
split='valid', net_type=net_type, **data_config)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=4,
pin_memory=True, drop_last=True)
valid_loader = DataLoader(valid_dataset, batch_size=1, shuffle=False, num_workers=4, pin_memory=True)
with tqdm(train_loader) as _tqdm:
for i, batched in enumerate(_tqdm):
images, labels = batched
if fp16:
images = images.half()
images, labels = images.to(device), labels.to(device)
optimizer.zero_grad()
preds = model(images)
if net_type == 'deeplab':
preds = F.interpolate(preds, size=labels.shape[1:], mode='bilinear', align_corners=True)
if fp16:
loss = loss_fn(preds.float(), labels)
else:
loss = loss_fn(preds, labels)
preds_np = preds.detach().cpu().numpy()
labels_np = labels.detach().cpu().numpy()
iou = compute_iou_batch(np.argmax(preds_np, axis=1), labels_np, classes)
_tqdm.set_postfix(OrderedDict(seg_loss=f'{loss.item():.5f}', iou=f'{iou:.3f}'))
train_losses.append(loss.item())
train_ious.append(iou)
ma_loss= 0.01*loss.item() + 0.99 * ma_loss
ma_iou= 0.01*iou + 0.99 * ma_iou
plotter.plot('loss', 'train', 'iteration Loss', i_iter, loss.item())
plotter.plot('iou', 'train', 'iteration iou', i_iter, iou)
plotter.plot('loss', 'ma_loss', 'iteration Loss', i_iter, ma_loss)
plotter.plot('iou', 'ma_iou', 'iteration iou', i_iter, ma_iou)
if fp16:
optimizer.backward(loss)
else:
loss.backward()
optimizer.step()
i_iter += 1
scheduler.step()
train_loss = np.mean(train_losses)
train_iou = np.nanmean(train_ious)
logger.info(f'train loss: {train_loss}')
logger.info(f'train iou: {train_iou}')
plotter.plot('loss-epoch', 'train', 'iteration Loss', i_epoch, train_loss)
plotter.plot('iou-epoch', 'train', 'iteration iou', i_epoch, train_iou)
torch.save(model.state_dict(), output_dir.joinpath('model_tmp.pth'))
torch.save(optimizer.state_dict(), output_dir.joinpath('opt_tmp.pth'))
valid_losses = []
valid_ious = []
model.eval()
with torch.no_grad():
with tqdm(valid_loader) as _tqdm:
for batched in _tqdm:
images, labels = batched
if fp16:
images = images.half()
images, labels = images.to(device), labels.to(device)
preds = model.tta(images, net_type=net_type)
if fp16:
loss = loss_fn(preds.float(), labels)
else:
loss = loss_fn(preds, labels)
preds_np = preds.detach().cpu().numpy()
labels_np = labels.detach().cpu().numpy()
# I changed a parameter in the compute_iou method to prevent it from yielding nans
iou = compute_iou_batch(np.argmax(preds_np, axis=1), labels_np, classes)
_tqdm.set_postfix(OrderedDict(seg_loss=f'{loss.item():.5f}', iou=f'{iou:.3f}'))
valid_losses.append(loss.item())
valid_ious.append(iou)
valid_loss = np.mean(valid_losses)
valid_iou = np.mean(valid_ious)
logger.info(f'valid seg loss: {valid_loss}')
logger.info(f'valid iou: {valid_iou}')
plotter.plot('loss-epoch', 'valid', 'iteration Loss', i_epoch, valid_loss)
plotter.plot('iou-epoch', 'valid', 'iteration iou', i_epoch, valid_iou)
if best_metrics < valid_iou:
best_metrics = valid_iou
logger.info('Best Model!')
torch.save(model.state_dict(), output_dir.joinpath('model.pth'))
torch.save(optimizer.state_dict(), output_dir.joinpath('opt.pth'))
loss_history.append([train_loss, valid_loss])
iou_history.append([train_iou, valid_iou])
history_ploter(loss_history, log_dir.joinpath('loss.png'))
history_ploter(iou_history, log_dir.joinpath('iou.png'))
history_dict = {'loss': loss_history,
'iou': iou_history,
'best_metrics': best_metrics}
with open(log_dir.joinpath('history.pkl'), 'wb') as f:
pickle.dump(history_dict, f)
def eval_from_model(split,
output_channels,
model_path,
postproc=False,
vis=True,
debug=True,
mean_AP=False):
model_path = Path(model_path)
path, model_dir = os.path.split(
model_path.parent) # separate path and filename
device = torch.device('cuda:0' if torch.cuda.is_available() else
'cpu') #work on GPU if available
print(f'Device: {device}')
if 'mnv2' in model_dir:
model = SPPNet(enc_type='mobilenetv2',
dec_type='maspp',
output_channels=output_channels).to(device)
defects = True
else:
model = SPPNet(output_channels=output_channels).to(device)
defects = False
if device == torch.device('cpu'):
param = torch.load(model_path, map_location='cpu'
) # parameters saved in checkpoint via model_path
else:
param = torch.load(
model_path) # parameters saved in checkpoint via model_path
print(f'Parameters loaded from {model_path}')
model.load_state_dict(param) #apply method load_state_dict to model?
del param # delete parameters? Reduce memory usage?
dataset = SherbrookeDataset(
split=split, net_type='deeplab',
defects=defects) #reach cityscapes dataset, validation split
classes = np.arange(1, dataset.n_classes)
img_paths = dataset.img_paths
base_dir = dataset.base_dir
split = dataset.split
if len(img_paths) == 0:
raise ValueError('Your dataset seems empty...')
else:
print(f'{len(img_paths)} images found in {base_dir}\\{split}')
model.eval() #apply eval method on model. ?
#print(f'Files containing \'{filetype}\' will be converted to \'{colortype}\' colormap and saved to:\n{output_folder}')
valid_ious = []
count = 0
predicted_boxes = {}
ground_truth_boxes = {}
with torch.no_grad():
#dataloader is a 2 element list with images and labels as torch tensors
print('Generating predictions...')
with tqdm(range(len(dataset))) as _tqdm:
for i in _tqdm:
count += 1
if count % 1 == 10:
print(f'Evaluation progress: {count}/{len(img_paths)}')
image, label = dataset[i]
img_path = dataset.img_paths[i]
orig_image = np.array(Image.open(img_path))
filename = img_path.name
#if isinstance(image, tuple): #take only image in label is also returned by __getitem__
# image = image[0]
image = image[
None] # mimick dataloader with 4th channel (batch channel)
image = image.to(device)
# next line reaches to tta.py --> net.py --> xception.py ...
# output: predictions (segmentation maps)
pred = model.tta(image, net_type='deeplab')
# pred = model(image)
# pred = F.interpolate(pred, size=label.shape, mode='bilinear', align_corners=True)
# take first pred of single item list of preds...
pred = pred[0]
softmax = torch.nn.Softmax(dim=1)
pred = softmax(pred)
#pred = softmax_from_feat_map(pred)
pred = pred.detach().cpu().numpy()
label = label.numpy()
if pred.shape[1] / pred.shape[0] == 2:
pred, label = dataset.postprocess(pred, label)
if mean_AP and not postproc:
raise Exception(
'postproc argument in eval_from_model function must be true if mean_AP is set to True'
)
elif postproc:
# take channel corresponding to softmax scores in channel 1 (class 1). Reduces array to 2D
pred = pred[1, :, :]
if dataset.defects:
# set all pixel in pred corresponding to an ignore_pixel in label to 0
pred[label == dataset.ignore_index] = 0
if mean_AP:
val_at_perc = 0.0002
# print(
# f'Value at median in prediction is: {val_at_perc}')
#create array copy and wreplace all values under threshold by nan values
pred_masked = np.where(pred >= val_at_perc, pred,
np.nan)
#create copy of pred array and set all values above threshold to 1 and under to 0
pred_binary = threshold(pred.copy(), value=val_at_perc)
# set values under 0.5 to 0, else to 1. result: binary array
bbox_list, scores_list = contour_proc(
pred_binary, pred_masked)
# add key to predicted_boxes: {'filename': {'boxes':bbox_list, 'scores':scores_list}}
predicted_boxes.update({
filename: {
"boxes": bbox_list,
"scores": scores_list
}
})
# pred = filter_by_activation(pred, percentile=90)
# pred = threshold(pred)
bbox_list_lbl, _ = contour_proc(label, label.copy())
# add key to predicted_boxes: {'filename': {'boxes':bbox_list, 'scores':scores_list}}
ground_truth_boxes.update({filename: bbox_list_lbl})
pred_masked = np.where(pred >= val_at_perc, pred,
np.nan)
pred_binary = threshold(
pred.copy(), value=val_at_perc
) # set values under 0.5 to 0, else to 1. result: binary array
bbox_list, scores_list = contour_proc(
pred_binary, pred_masked)
#add key to predicted_boxes: {'filename': {'boxes':bbox_list, 'scores':scores_list}}
predicted_boxes.update({
filename: {
"boxes": bbox_list,
"scores": scores_list
}
})
pred = filter_by_activation(pred, percentile=90)
else:
pred = np.argmax(pred, axis=0)
if debug:
print(f'Label unique values: {np.unique(label)}')
# print(np.unique(pred))
if output_channels == 19:
# create mask for values other than 0 (background) and 1(sidewalk)
for i in range(2, 19):
pred[
pred ==
i] = 0 # convert these classes to background value
if dataset.split == 'val':
# compute iou
iou = compute_iou_batch(pred, label, classes)
print(f'Iou for {filename}: {iou}')
valid_ious.append(iou)
if vis:
output_dir = Path(
f'../data/output/{model_dir}/{split}/{os.path.split(img_path.parent)[1]}'
)
output_dir.mkdir(parents=True, exist_ok=True)
folder = output_dir.joinpath('figures')
folder.mkdir(parents=True, exist_ok=True)
label[label == 255] = 0
conf_overlay = np.add(label, pred * 2)
print(np.unique(conf_overlay))
confus_overlay = vis_segmentation(conf_overlay, img_path)
confus_overlay.save(
folder.joinpath(f'{filename}_overlay.jpg'))
elif dataset.split == 'bootstrap':
# convert 1 values to 8. For bootstrapping.
pred = encode_mask(pred)
pred_pil = Image.fromarray(pred.astype(np.uint8))
img_pil = Image.open(img_path)
if pred_pil.size != img_pil.size:
pred_pil = pred_pil.resize(
(img_pil.size[0], img_pil.size[1]), Image.NEAREST)
pred_pil.save(
output_dir.joinpath(f'{filename}_gtFine_labelIds.png'))
#save_colormap(pred[0], savename, output_dir, filetype, colortype=colortype)
else:
raise NotImplementedError
_tqdm.set_postfix(OrderedDict(last_image=f'{filename}'))
if mean_AP:
with open('predicted_boxes_GSV.json', 'w') as json_file:
json.dump(predicted_boxes, json_file, sort_keys=True)
with open('ground_truth_boxes_GSV.json', 'w') as json_file:
json.dump(ground_truth_boxes, json_file, sort_keys=True)
if dataset.split == 'val':
valid_iou = np.nanmean(valid_ious)
print(f'mean valid iou: {valid_iou}')
#print(f'Confusion matrix: \n{conf_mat}')
with open('predicted_boxes_GSV.json', 'w') as json_file:
json.dump(predicted_boxes, json_file) # , sort_keys=True)
with open('ground_truth_boxes_GSV.json', 'w') as json_file:
json.dump(ground_truth_boxes, json_file, sort_keys=True)
if vis:
print(f'Files were be saved to {output_dir.parent}')
