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}')