def loss_calc(pred, label):
label = Variable(label.long()).cuda()
if len(gpus) > 1:
criterion = torch.nn.DataParallel(CrossEntropy2d(ignore_label=ignore_label), device_ids=gpus).cuda() # Ignore label ??
else:
criterion = CrossEntropy2d(ignore_label=ignore_label).cuda() # Ignore label ??
return criterion(pred, label)
def loss_calc(pred, label, gpu, usecuda):
if usecuda:
label = Variable(label.long()).cuda(gpu)
criterion = CrossEntropy2d().cuda(gpu)
result = criterion(pred, label)
else:
label = Variable(label.long())
criterion = CrossEntropy2d()
result = criterion(pred, label)
return result
def loss_calc(pred, label):
# out shape batch_size x channels x h x w -> batch_size x channels x h x w
# label shape h x w x 1 x batch_size -> batch_size x 1 x h x w
label = Variable(label.long()).cuda()
criterion = CrossEntropy2d().cuda()
return criterion(pred, label)
def loss_calc(pred, label, gpu, ignore_label, train_name, weights):
"""
This function returns cross entropy loss for semantic segmentation
"""
# out shape batch_size x channels x h x w -> batch_size x channels x h x w
# label shape h x w x 1 x batch_size -> batch_size x 1 x h x w
try:
label = Variable(label.long()).cuda(gpu)
if args.weighted_loss == True:
criterion = CrossEntropy2d(ignore_label=ignore_label, weight = weights).cuda(gpu)
else:
criterion = CrossEntropy2d(ignore_label=ignore_label).cuda(gpu)
return criterion(pred, label)
except RuntimeError:
print("RuntimeError", train_name)
return 0
def loss_calc(pred, label, gpu):
"""
This function returns cross entropy loss for semantic segmentation
"""
criterion = CrossEntropy2d().cuda(gpu)
return criterion(pred, label)
def loss_calc(pred, label, device):
"""
This function returns cross entropy loss for semantic segmentation
"""
# out shape batch_size x channels x h x w -> batch_size x channels x h x w
# label shape h x w x 1 x batch_size -> batch_size x 1 x h x w
label = label.long().to(device)
criterion = CrossEntropy2d(NUM_CLASSES).to(device)
return criterion(pred, label)
def loss_calc(pred, label, gpu):
"""
This function returns cross entropy loss for semantic segmentation
"""
# out shape batch_size x channels x h x w -> batch_size x channels x h x w
# label shape h x w x 1 x batch_size -> batch_size x 1 x h x w
label = Variable(label.long()).cuda(gpu)
criterion = CrossEntropy2d().cuda(gpu)
return criterion(pred, label)
def loss_calc(pred, label, gpu, ignore_label, train_name):
"""
This function returns cross entropy loss for semantic segmentation
"""
try:
label = Variable(label.long()).cuda(gpu)
criterion = CrossEntropy2d(ignore_label=ignore_label).cuda(gpu)
return criterion(pred, label)
except RuntimeError:
print("RuntimeError", train_name)
return 0
def loss_calc(pred, label, gpu, alpha=0):
"""
This function returns cross entropy loss for semantic segmentation
"""
other_label = (label + 0).long()
tem_pred = pred + 0
if alpha != 0:
tem = F.softmax(tem_pred, 1)
value, posi = torch.max(F.softmax(tem_pred, 1), 1)
soft_pred, _ = torch.max(F.softmax(tem_pred, 1), 1)
other_label[soft_pred>alpha] = 255
# print(torch.sum(soft_pred-255 == torch.zeros(soft_pred.size()).long()))
criterion = CrossEntropy2d().cuda(gpu)
# print("pred",pred.size())
# print("soft_label",soft_label.size())
return criterion(pred, label), other_label
def main():
print(config)
cudnn.enabled = True
torch.manual_seed(random_seed)
torch.cuda.manual_seed(random_seed)
np.random.seed(random_seed)
random.seed(random_seed)
torch.backends.cudnn.deterministic = True
if pretraining == 'COCO': # depending the pretraining, normalize with bgr or rgb
from utils.transformsgpu import normalize_bgr as normalize
else:
from utils.transformsgpu import normalize_rgb as normalize
batch_size_unlabeled = int(
batch_size /
2) # because of augmentation anchoring, 2 augmentations per sample
batch_size_labeled = int(batch_size * 1)
assert batch_size_unlabeled >= 2, "batch size should be higher than 2"
assert batch_size_labeled >= 2, "batch size should be higher than 2"
RAMP_UP_ITERS = 2000 # iterations until contrastive and self-training are taken into account
# DATASETS / LOADERS
if dataset == 'pascal_voc':
data_loader = get_loader(dataset)
data_path = get_data_path(dataset)
train_dataset = data_loader(data_path,
crop_size=input_size,
scale=False,
mirror=False,
pretraining=pretraining)
elif dataset == 'cityscapes':
data_loader = get_loader('cityscapes')
data_path = get_data_path('cityscapes')
if deeplabv2:
data_aug = Compose([RandomCrop_city(input_size)])
else: # for deeplabv3 original resolution
data_aug = Compose([RandomCrop_city_highres(input_size)])
train_dataset = data_loader(data_path,
is_transform=True,
augmentations=data_aug,
img_size=input_size,
pretraining=pretraining)
train_dataset_size = len(train_dataset)
print('dataset size: ', train_dataset_size)
partial_size = labeled_samples
print('Training on number of samples:', partial_size)
# class weighting taken unlabeled data into acount in an incremental fashion.
class_weights_curr = ClassBalancing(
labeled_iters=int(labeled_samples / batch_size_labeled),
unlabeled_iters=int(
(train_dataset_size - labeled_samples) / batch_size_unlabeled),
n_classes=num_classes)
# Memory Bank
feature_memory = FeatureMemory(num_samples=labeled_samples,
dataset=dataset,
memory_per_class=256,
feature_size=256,
n_classes=num_classes)
# select the partition
if split_id is not None:
train_ids = pickle.load(open(split_id, 'rb'))
print('loading train ids from {}'.format(split_id))
else:
train_ids = np.arange(train_dataset_size)
np.random.shuffle(train_ids)
# Samplers for labeled data
train_sampler = data.sampler.SubsetRandomSampler(train_ids[:partial_size])
trainloader = data.DataLoader(train_dataset,
batch_size=batch_size_labeled,
sampler=train_sampler,
num_workers=num_workers,
pin_memory=True)
trainloader_iter = iter(trainloader)
# Samplers for unlabeled data
train_remain_sampler = data.sampler.SubsetRandomSampler(
train_ids[partial_size:])
trainloader_remain = data.DataLoader(train_dataset,
batch_size=batch_size_unlabeled,
sampler=train_remain_sampler,
num_workers=num_workers,
pin_memory=True)
trainloader_remain_iter = iter(trainloader_remain)
# supervised loss
supervised_loss = CrossEntropy2d(ignore_label=ignore_label).cuda()
''' Deeplab model '''
# Define network
if deeplabv2:
if pretraining == 'COCO': # coco and imagenet resnet architectures differ a little, just on how to do the stride
from model.deeplabv2 import Res_Deeplab
else: # imagenet pretrained (more modern modification)
from model.deeplabv2_imagenet import Res_Deeplab
# load pretrained parameters
if pretraining == 'COCO':
saved_state_dict = model_zoo.load_url(
'http://vllab1.ucmerced.edu/~whung/adv-semi-seg/resnet101COCO-41f33a49.pth'
) # COCO pretraining
else:
saved_state_dict = model_zoo.load_url(
'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth'
) # iamgenet pretrainning
else:
from model.deeplabv3 import Res_Deeplab50 as Res_Deeplab
saved_state_dict = model_zoo.load_url(
'https://download.pytorch.org/models/resnet50-19c8e357.pth'
) # iamgenet pretrainning
# create network
model = Res_Deeplab(num_classes=num_classes)
# Copy loaded parameters to model
new_params = model.state_dict().copy()
for name, param in new_params.items():
if name in saved_state_dict and param.size(
) == saved_state_dict[name].size():
new_params[name].copy_(saved_state_dict[name])
model.load_state_dict(new_params)
# Optimizer for segmentation network
learning_rate_object = Learning_Rate_Object(
config['training']['learning_rate'])
optimizer = torch.optim.SGD(model.optim_parameters(learning_rate_object),
lr=learning_rate,
momentum=momentum,
weight_decay=weight_decay)
ema_model = create_ema_model(model, Res_Deeplab)
ema_model.train()
ema_model = ema_model.cuda()
model.train()
model = model.cuda()
cudnn.benchmark = True
if not os.path.exists(checkpoint_dir):
os.makedirs(checkpoint_dir)
with open(checkpoint_dir + '/config.json', 'w') as handle:
json.dump(config, handle, indent=4, sort_keys=False)
pickle.dump(train_ids,
open(os.path.join(checkpoint_dir, 'train_split.pkl'), 'wb'))
interp = nn.Upsample(size=(input_size[0], input_size[1]),
mode='bilinear',
align_corners=True)
epochs_since_start = 0
start_iteration = 0
best_mIoU = 0 # best metric while training
iters_without_improve = 0
# TRAINING
for i_iter in range(start_iteration, num_iterations):
model.train() # set mode to training
optimizer.zero_grad()
loss_l_value = 0.
adjust_learning_rate(optimizer, i_iter)
labeled_turn = i_iter % 2 == 0
if labeled_turn: # labeled data optimization
''' LABELED SAMPLES '''
# Get batch
try:
batch = next(trainloader_iter)
if batch[0].shape[0] != batch_size_labeled:
batch = next(trainloader_iter)
except: # finish epoch, rebuild the iterator
epochs_since_start = epochs_since_start + 1
# print('Epochs since start: ',epochs_since_start)
trainloader_iter = iter(trainloader)
batch = next(trainloader_iter)
images, labels, _, _, _ = batch
images = images.cuda()
labels = labels.cuda()
model.train()
if dataset == 'cityscapes':
class_weights_curr.add_frequencies_labeled(
labels.cpu().numpy())
images_aug, labels_aug, _, _ = augment_samples(
images,
labels,
None,
random.random() < 0.2,
batch_size_labeled,
ignore_label,
weak=True)
# labeled data
labeled_pred, labeled_features = model(normalize(
images_aug, dataset),
return_features=True)
labeled_pred = interp(labeled_pred)
# apply class balance for cityspcaes dataset
class_weights = torch.from_numpy(np.ones((num_classes))).cuda()
if i_iter > RAMP_UP_ITERS and dataset == 'cityscapes':
class_weights = torch.from_numpy(
class_weights_curr.get_weights(num_iterations,
only_labeled=False)).cuda()
loss = 0
# SUPERVISED SEGMENTATION
labeled_loss = supervised_loss(labeled_pred,
labels_aug,
weight=class_weights.float())
loss = loss + labeled_loss
# CONTRASTIVE LEARNING
if i_iter > RAMP_UP_ITERS - 1000:
# Build Memory Bank 1000 iters before starting to do contrsative
with torch.no_grad():
# Get feature vectors from labeled images with EMA model
if use_teacher:
labeled_pred_ema, labeled_features_ema = ema_model(
normalize(images_aug, dataset),
return_features=True)
else:
model.eval()
labeled_pred_ema, labeled_features_ema = model(
normalize(images_aug, dataset),
return_features=True)
model.train()
labeled_pred_ema = interp(labeled_pred_ema)
probability_prediction_ema, label_prediction_ema = torch.max(
torch.softmax(labeled_pred_ema,
dim=1), dim=1) # Get pseudolabels
# Resize labels, predictions and probabilities, to feature map resolution
labels_down = nn.functional.interpolate(
labels_aug.float().unsqueeze(1),
size=(labeled_features_ema.shape[2],
labeled_features_ema.shape[3]),
mode='nearest').squeeze(1)
label_prediction_down = nn.functional.interpolate(
label_prediction_ema.float().unsqueeze(1),
size=(labeled_features_ema.shape[2],
labeled_features_ema.shape[3]),
mode='nearest').squeeze(1)
probability_prediction_down = nn.functional.interpolate(
probability_prediction_ema.float().unsqueeze(1),
size=(labeled_features_ema.shape[2],
labeled_features_ema.shape[3]),
mode='nearest').squeeze(1)
# get mask where the labeled predictions are correct and have a confidence higher than 0.95
mask_prediction_correctly = (
(label_prediction_down == labels_down).float() *
(probability_prediction_down > 0.95).float()).bool()
# Apply the filter mask to the features and its labels
labeled_features_correct = labeled_features_ema.permute(
0, 2, 3, 1)
labels_down_correct = labels_down[mask_prediction_correctly]
labeled_features_correct = labeled_features_correct[
mask_prediction_correctly, ...]
# get projected features
with torch.no_grad():
if use_teacher:
proj_labeled_features_correct = ema_model.projection_head(
labeled_features_correct)
else:
model.eval()
proj_labeled_features_correct = model.projection_head(
labeled_features_correct)
model.train()
# updated memory bank
feature_memory.add_features_from_sample_learned(
ema_model, proj_labeled_features_correct,
labels_down_correct, batch_size_labeled)
if i_iter > RAMP_UP_ITERS:
'''
CONTRASTIVE LEARNING ON LABELED DATA. Force features from labeled samples, to be similar to other features from the same class (which also leads to good predictions
'''
# mask features that do not have ignore label in the labels (zero-padding because of data augmentation like resize/crop)
mask_prediction_correctly = (labels_down != ignore_label)
labeled_features_all = labeled_features.permute(0, 2, 3, 1)
labels_down_all = labels_down[mask_prediction_correctly]
labeled_features_all = labeled_features_all[
mask_prediction_correctly, ...]
# get predicted features
proj_labeled_features_all = model.projection_head(
labeled_features_all)
pred_labeled_features_all = model.prediction_head(
proj_labeled_features_all)
# Apply contrastive learning loss
loss_contr_labeled = contrastive_class_to_class_learned_memory(
model, pred_labeled_features_all, labels_down_all,
num_classes, feature_memory.memory)
loss = loss + loss_contr_labeled * 0.1
else: # unlabeled data optimization
''' UNLABELED SAMPLES '''
try:
batch_remain = next(trainloader_remain_iter)
if batch_remain[0].shape[0] != batch_size_unlabeled:
batch_remain = next(trainloader_remain_iter)
except:
trainloader_remain_iter = iter(trainloader_remain)
batch_remain = next(trainloader_remain_iter)
# Unlabeled
unlabeled_images, _, _, _, _ = batch_remain
unlabeled_images = unlabeled_images.cuda()
# Create pseudolabels
with torch.no_grad():
if use_teacher:
logits_u_w, features_weak_unlabeled = ema_model(
normalize(unlabeled_images, dataset),
return_features=True)
else:
model.eval()
logits_u_w, features_weak_unlabeled = model(
normalize(unlabeled_images, dataset),
return_features=True)
logits_u_w = interp(
logits_u_w).detach() # prediction unlabeled
softmax_u_w = torch.softmax(logits_u_w, dim=1)
max_probs, pseudo_label = torch.max(softmax_u_w,
dim=1) # Get pseudolabels
model.train()
if dataset == 'cityscapes':
class_weights_curr.add_frequencies_unlabeled(
pseudo_label.cpu().numpy())
'''
UNLABELED DATA
'''
unlabeled_images_aug1, pseudo_label1, max_probs1, unlabeled_aug1_params = augment_samples(
unlabeled_images, pseudo_label, max_probs,
i_iter > RAMP_UP_ITERS and random.random() < 0.75,
batch_size_unlabeled, ignore_label)
unlabeled_images_aug2, pseudo_label2, max_probs2, unlabeled_aug2_params = augment_samples(
unlabeled_images, pseudo_label, max_probs,
i_iter > RAMP_UP_ITERS and random.random() < 0.75,
batch_size_unlabeled, ignore_label)
# concatenate two augmentations of unlabeled data
joined_unlabeled = torch.cat(
(unlabeled_images_aug1, unlabeled_images_aug2), dim=0)
joined_pseudolabels = torch.cat((pseudo_label1, pseudo_label2),
dim=0)
joined_maxprobs = torch.cat((max_probs1, max_probs2), dim=0)
pred_joined_unlabeled, features_joined_unlabeled = model(
normalize(joined_unlabeled, dataset), return_features=True)
pred_joined_unlabeled = interp(pred_joined_unlabeled)
# apply clas balance for cityspcaes dataset
if dataset == 'cityscapes':
class_weights = torch.from_numpy(
class_weights_curr.get_weights(num_iterations,
only_labeled=False)).cuda()
else:
class_weights = torch.from_numpy(np.ones((num_classes))).cuda()
loss = 0
# SELF-SUPERVISED SEGMENTATION
unlabeled_loss = CrossEntropyLoss2dPixelWiseWeighted(
ignore_index=ignore_label,
weight=class_weights.float()).cuda() #
# Pseudo-label weighting
pixelWiseWeight = sigmoid_ramp_up(
i_iter, RAMP_UP_ITERS) * torch.ones(
joined_maxprobs.shape).cuda()
pixelWiseWeight = pixelWiseWeight * torch.pow(
joined_maxprobs.detach(), 6)
# Pseudo-label loss
loss_ce_unlabeled = unlabeled_loss(pred_joined_unlabeled,
joined_pseudolabels,
pixelWiseWeight)
loss = loss + loss_ce_unlabeled
# entropy loss
valid_mask = (joined_pseudolabels != ignore_label).unsqueeze(1)
loss = loss + entropy_loss(
torch.nn.functional.softmax(pred_joined_unlabeled, dim=1),
valid_mask) * 0.01
if i_iter > RAMP_UP_ITERS:
'''
CONTRASTIVE LEARNING ON UNLABELED DATA. align unlabeled features to labeled features
'''
joined_pseudolabels_down = nn.functional.interpolate(
joined_pseudolabels.float().unsqueeze(1),
size=(features_joined_unlabeled.shape[2],
features_joined_unlabeled.shape[3]),
mode='nearest').squeeze(1)
# mask features that do not have ignore label in the labels (zero-padding because of data augmentation like resize/crop)
mask = (joined_pseudolabels_down != ignore_label)
features_joined_unlabeled = features_joined_unlabeled.permute(
0, 2, 3, 1)
features_joined_unlabeled = features_joined_unlabeled[mask,
...]
joined_pseudolabels_down = joined_pseudolabels_down[mask]
# get predicted features
proj_feat_unlabeled = model.projection_head(
features_joined_unlabeled)
pred_feat_unlabeled = model.prediction_head(
proj_feat_unlabeled)
# Apply contrastive learning loss
loss_contr_unlabeled = contrastive_class_to_class_learned_memory(
model, pred_feat_unlabeled, joined_pseudolabels_down,
num_classes, feature_memory.memory)
loss = loss + loss_contr_unlabeled * 0.1
# common code
loss_l_value += loss.item()
# optimize
loss.backward()
optimizer.step()
m = 1 - (1 - 0.995) * (math.cos(math.pi * i_iter / num_iterations) +
1) / 2
ema_model = update_ema_variables(ema_model=ema_model,
model=model,
alpha_teacher=m,
iteration=i_iter)
if i_iter % save_checkpoint_every == 0 and i_iter != 0:
_save_checkpoint(i_iter, model, optimizer, config)
if i_iter % val_per_iter == 0 and i_iter != 0:
print('iter = {0:6d}/{1:6d}'.format(i_iter, num_iterations))
model.eval()
mIoU, eval_loss = evaluate(model,
dataset,
deeplabv2=deeplabv2,
ignore_label=ignore_label,
save_dir=checkpoint_dir,
pretraining=pretraining)
model.train()
if mIoU > best_mIoU:
best_mIoU = mIoU
if save_teacher:
_save_checkpoint(i_iter,
ema_model,
optimizer,
config,
save_best=True)
else:
_save_checkpoint(i_iter,
model,
optimizer,
config,
save_best=True)
iters_without_improve = 0
else:
iters_without_improve += val_per_iter
'''
if the performance has not improve in N iterations, try to reload best model to optimize again with a lower LR
Simulating an iterative training'''
if iters_without_improve > num_iterations / 5.:
print('Re-loading a previous best model')
checkpoint = torch.load(
os.path.join(checkpoint_dir, f'best_model.pth'))
model.load_state_dict(checkpoint['model'])
ema_model = create_ema_model(model, Res_Deeplab)
ema_model.train()
ema_model = ema_model.cuda()
model.train()
model = model.cuda()
iters_without_improve = 0 # reset timer
_save_checkpoint(num_iterations, model, optimizer, config)
# FINISH TRAINING, evaluate again
model.eval()
mIoU, eval_loss = evaluate(model,
dataset,
deeplabv2=deeplabv2,
ignore_label=ignore_label,
save_dir=checkpoint_dir,
pretraining=pretraining)
model.train()
if mIoU > best_mIoU and save_best_model:
best_mIoU = mIoU
_save_checkpoint(i_iter, model, optimizer, config, save_best=True)
# TRY IMPROVING BEST MODEL WITH EMA MODEL OR UPDATING BN STATS
# Load best model
checkpoint = torch.load(os.path.join(checkpoint_dir, f'best_model.pth'))
model.load_state_dict(checkpoint['model'])
model = model.cuda()
model = update_BN_weak_unlabeled_data(model, normalize,
batch_size_unlabeled,
trainloader_remain)
model.eval()
mIoU, eval_loss = evaluate(model,
dataset,
deeplabv2=deeplabv2,
ignore_label=ignore_label,
save_dir=checkpoint_dir,
pretraining=pretraining)
model.train()
if mIoU > best_mIoU and save_best_model:
best_mIoU = mIoU
_save_checkpoint(i_iter, model, optimizer, config, save_best=True)
print('BEST MIOU')
print(max(best_mIoU_improved, best_mIoU))
end = timeit.default_timer()
print('Total time: ' + str(end - start) + ' seconds')
def loss_calc(pred, label, gpu):
label = Variable(label.long()).cuda(gpu)
criterion = CrossEntropy2d(ignore_label=args.ignore_label).cuda(gpu)
return criterion(pred, label)
def evaluate(model,
dataset,
ignore_label=250,
save_output_images=False,
save_dir=None,
input_size=(512, 1024)):
if dataset == 'cityscapes':
num_classes = 19
data_loader = get_loader('cityscapes')
data_path = get_data_path('cityscapes')
test_dataset = data_loader(data_path,
img_size=input_size,
img_mean=IMG_MEAN,
is_transform=True,
split='val')
testloader = data.DataLoader(test_dataset,
batch_size=1,
shuffle=False,
pin_memory=True)
interp = nn.Upsample(size=input_size,
mode='bilinear',
align_corners=True)
ignore_label = 250
elif dataset == 'gta':
num_classes = 19
data_loader = get_loader('gta')
data_path = get_data_path('gta')
test_dataset = data_loader(data_path,
list_path='./data/gta5_list/train.txt',
img_size=(1280, 720),
mean=IMG_MEAN)
testloader = data.DataLoader(test_dataset,
batch_size=1,
shuffle=True,
pin_memory=True)
interp = nn.Upsample(size=(720, 1280),
mode='bilinear',
align_corners=True)
ignore_label = 255
print('Evaluating, found ' + str(len(testloader)) + ' images.')
data_list = []
colorize = VOCColorize()
total_loss = []
for index, batch in enumerate(testloader):
image, label, size, name, _ = batch
size = size[0]
#if index > 500:
# break
with torch.no_grad():
output = model(Variable(image).cuda())
output = interp(output)
label_cuda = Variable(label.long()).cuda()
criterion = CrossEntropy2d(
ignore_label=ignore_label).cuda() # Ignore label ??
loss = criterion(output, label_cuda)
total_loss.append(loss.item())
output = output.cpu().data[0].numpy()
if dataset == 'cityscapes':
gt = np.asarray(label[0].numpy(), dtype=np.int)
elif dataset == 'gta':
gt = np.asarray(label[0].numpy(), dtype=np.int)
output = output.transpose(1, 2, 0)
output = np.asarray(np.argmax(output, axis=2), dtype=np.int)
data_list.append([gt.flatten(), output.flatten()])
if (index + 1) % 100 == 0:
print('%d processed' % (index + 1))
if save_dir:
filename = os.path.join(save_dir, 'result.txt')
else:
filename = None
mIoU = get_iou(data_list, num_classes, dataset, filename)
loss = np.mean(total_loss)
return mIoU, loss
def evaluate(model,
dataset,
ignore_label=250,
save_output_images=False,
save_dir=None,
input_size=(512, 1024)):
if dataset == 'pascal_voc':
num_classes = 21
input_size = (505, 505)
data_loader = get_loader(dataset)
data_path = get_data_path(dataset)
test_dataset = data_loader(data_path,
split="val",
crop_size=input_size,
scale=False,
mirror=False)
testloader = data.DataLoader(test_dataset,
batch_size=1,
shuffle=False,
pin_memory=True)
interp = nn.Upsample(size=input_size,
mode='bilinear',
align_corners=True)
elif dataset == 'cityscapes':
num_classes = 19
data_loader = get_loader('cityscapes')
data_path = get_data_path('cityscapes')
test_dataset = data_loader(data_path,
img_size=input_size,
is_transform=True,
split='val')
testloader = data.DataLoader(test_dataset,
batch_size=1,
shuffle=False,
pin_memory=True)
interp = nn.Upsample(size=input_size,
mode='bilinear',
align_corners=True)
elif dataset == 'semantic_kitti':
num_classes = 19 # ?
new_h = input_size[0]
new_w = input_size[1]
# data_loader = get_loader(dataset)
data_path = get_data_path(dataset)
# train_dataset = data_loader(data_path)
test_dataset = semantic_kitti.SemanticKitti(data_path +
"/dataset/sequences",
"val",
new_h=new_h,
new_w=new_w)
testloader = data.DataLoader(test_dataset,
batch_size=1,
shuffle=False,
pin_memory=True)
interp = nn.Upsample(size=(new_h, new_w),
mode='bilinear',
align_corners=True)
print('Evaluating, found ' + str(len(testloader)) + ' images.')
data_list = []
colorize = VOCColorize()
total_loss = []
for index, batch in enumerate(testloader):
image, label, size, name, _ = batch
size = size[0]
with torch.no_grad():
output = model(Variable(image).cuda())
output = interp(output)
label_cuda = Variable(label.long()).cuda()
criterion = CrossEntropy2d(
ignore_label=ignore_label).cuda() # Ignore label ??
loss = criterion(output, label_cuda)
total_loss.append(loss.item())
output = output.cpu().data[0].numpy()
if dataset == 'pascal_voc':
output = output[:, :size[0], :size[1]]
gt = np.asarray(label[0].numpy()[:size[0], :size[1]],
dtype=np.int)
elif dataset == 'cityscapes' or "semantic_kitti":
gt = np.asarray(label[0].numpy(), dtype=np.int)
output = output.transpose(1, 2, 0)
output = np.asarray(np.argmax(output, axis=2), dtype=np.int)
data_list.append([gt.reshape(-1), output.reshape(-1)])
if save_output_images:
if dataset == 'pascal_voc':
filename = os.path.join(save_dir, '{}.png'.format(name[0]))
color_file = Image.fromarray(
colorize(output).transpose(1, 2, 0), 'RGB')
color_file.save(filename)
if (index + 1) % 100 == 0:
print('%d processed' % (index + 1))
if save_dir:
filename = os.path.join(save_dir, 'result.txt')
else:
filename = None
mIoU = get_iou(data_list, num_classes, dataset, filename)
loss = np.mean(total_loss)
return mIoU, loss
def train_semi_sigmoid(generator, discriminator, optimG, optimD, trainloader_l,
trainloader_u, valoader, args):
best_miou = -1
print("sigmoid generator!!")
for epoch in range(args.start_epoch, args.max_epoch + 1):
generator.train()
trainloader_l_iter = iter(trainloader_l)
trainloader_u_iter = iter(trainloader_u)
print("Epoch: {}".format(epoch))
batch_id = 0
while (True):
batch_id += 1
itr = (len(trainloader_u) + len(trainloader_l)) * (epoch -
1) + batch_id
LGsemi_d = 0
LGsemi_c = 0
if epoch > args.wait_semi:
if random.random() < 0.5:
loader_l = trainloader_l_iter
loader_u = trainloader_u_iter
else:
loader_l = trainloader_u_iter
loader_u = trainloader_l_iter
# Check if the loader has a batch available
try:
img_u, mask_u, ohmask_u, _ = next(loader_u)
except:
trainloader_u_iter = iter(trainloader_u)
loader_u = trainloader_u_iter
img_u, mask_u, ohmask_u, _ = next(loader_u)
if args.nogpu:
img_u, mask_u, ohmask_u = Variable(img_u), Variable(
mask_u), Variable(ohmask_u)
else:
img_u, mask_u, ohmask_u = Variable(img_u.cuda()), Variable(
mask_u.cuda()), Variable(ohmask_u.cuda())
# semi unlabelled training
cpmap = generator(img_u)
cpmapsmax = nn.Sigmoid()(cmap)
# cpmapsmax = nn.Softmax2d()(cpmap)
conf = discriminator(cpmapsmax)
confsmax = nn.Softmax2d()(conf)
conflsmax = nn.LogSoftmax()(conf)
N = cpmap.size()[0]
H = cpmap.size()[2]
W = cpmap.size()[3]
# Adversarial Loss
targetr = Variable(torch.ones((N, H, W)).long())
if not args.nogpu:
targetr = targetr.cuda()
LGadv = nn.NLLLoss2d()(conflsmax, targetr)
LGadv_d = LGadv.data
hardpred = torch.max(cpmapsmax, 1)[1].squeeze(1)
idx = np.zeros(cpmap.data.cpu().numpy().shape, dtype=np.uint8)
idx = idx.transpose(0, 2, 3, 1)
confnp = confsmax[:, 1, ...].data.cpu().numpy()
hardprednp = hardpred.data.cpu().numpy()
idx[confnp > args.t_semi] = np.identity(
2, dtype=idx.dtype)[hardprednp[confnp > args.t_semi]]
LG = args.lam_adv * LGadv
if np.count_nonzero(idx) != 0:
cpmaplsmax = nn.LogSoftmax()(cpmap)
idx = Variable(
torch.from_numpy(idx.transpose(0, 3, 1,
2)).byte().cuda())
LGsemi_arr = cpmaplsmax.masked_select(idx.bool())
LGsemi = -1 * LGsemi_arr.mean()
LGsemi_d = LGsemi.data
# LGsemi_c = LGsemi.cpu().numpy()
LGsemi = args.lam_semi * LGsemi
# LG += LGsemi
LG.backward()
optimG = poly_lr_scheduler(optimG, args.g_lr, itr)
optimG.step()
################################################
# train labelled data #
################################################
loader_l = trainloader_l_iter
loader_u = trainloader_u_iter
try:
if random.random() < 0.5:
img_l, mask_l, ohmask_l, _ = next(loader_l)
else:
img_l, mask_l, ohmask_l, _ = next(loader_u)
except:
break
if args.nogpu:
img_l, mask_l, ohmask_l = Variable(img_l), Variable(
mask_l), Variable(ohmask_l)
else:
img_l, mask_l, ohmask_l = Variable(img_l.cuda()), Variable(
mask_l.cuda()), Variable(ohmask_l.cuda())
################################################
# Labelled data for Discriminator Training #
################################################
cpmap = generator(Variable(img_l.data, volatile=True))
# cpmap = nn.Softmax2d()(cpmap)
cpmap = nn.Sigmoid()(cpmap) # 4, 1, 320, 320
N = cpmap.size()[0]
H = cpmap.size()[2]
W = cpmap.size()[3]
# Generate the Real and Fake Labels
targetf = Variable(torch.zeros((N, H, W)).long())
targetr = Variable(torch.ones((N, H, W)).long())
if not args.nogpu:
targetf = targetf.cuda()
targetr = targetr.cuda()
# Train on Real
# confr = nn.LogSoftmax()(discriminator(ohmask_l.float()))
# print(mask_l.size(), ohmask_l.size())
tar_mask_l = mask_l.unsqueeze(1)
confr = nn.LogSoftmax()(discriminator(tar_mask_l.float()))
optimD.zero_grad()
if args.d_label_smooth != 0:
LDr = (1 - args.d_label_smooth) * nn.NLLLoss2d()(
confr, targetr) # mask_l
LDr += args.d_label_smooth * nn.NLLLoss2d()(
confr, targetf) # targetf mask_l
else:
LDr = nn.NLLLoss2d()(confr, targetr) # targetr mask_l
LDr.backward()
# Train on Fake
print("cpmap: ", cpmap.size())
conff = nn.LogSoftmax()(discriminator(Variable(cpmap.data)))
LDf = nn.NLLLoss2d()(conff, mask_l) # targetf
LDf.backward()
LDr_d = LDr.data
# LDr_c = LDr.cpu().numpy()
LDf_d = LDf.data
# LDf_c = LDf.cpu().numpy()
LD_d = LDr_d + LDf_d
# LD_c = LDr_c + LDf_c
optimD = poly_lr_scheduler(optimD, args.d_lr, itr)
optimD.step()
#####################################
# labelled data Generator Training #
#####################################
optimG.zero_grad()
optimD.zero_grad()
cpmap = generator(img_l)
cpmapsmax = nn.Sigmoid()(cpmap)
print("cpmapsmax: ", cpmapsmax.size())
# cpmapsmax = nn.Softmax2d()(cpmap)
# cpmaplsmax = nn.LogSoftmax()(cpmap)
conff = nn.LogSoftmax()(discriminator(cpmapsmax))
# LGce = nn.NLLLoss2d()(cpmaplsmax,mask_l)
LGCe = CrossEntropy2d()(cpmapsmax, mask_l)
LGadv = nn.NLLLoss2d()(conff, targetr) # targetr mask_l
LGadv_d = LGadv.data
# LGadv_c = LGadv.cpu().numpy()
LGce_d = LGce.data
# LGce_c = LGce.cpu().numpy()
# LGsemi_d = 0 # No semi-supervised training
LGadv = args.lam_adv * LGadv
(LGce + LGadv).backward()
optimG = poly_lr_scheduler(optimG, args.g_lr, itr)
optimG.step()
LGseg_d = LGce_d + LGadv_d + LGsemi_d
# LGseg_c = LGce_c + LGadv_c + LGsemi_c
# training_log = [epoch,itr,LD_c,LDr_c,LDf_c,LGseg_c,LGce_c,LGadv_c,LGsemi_c]
print("[{}][{}] LD: {:.4f} LD_fake: {:.4f} LD_real: {:.4f} LG: {:.4f} LG_ce: {:.4f} LG_adv: {:.4f} LG_semi: {:.4f}"\
.format(epoch,itr,LD_d,LDr_d,LDf_d,LGseg_d,LGce_d,LGadv_d,LGsemi_d))
# best_miou = snapshot(generator,valoader,epoch,best_miou,args.snapshot_dir,args.prefix)
best_miou = snapshot_segdis(generator, discriminator, valoader, epoch,
best_miou, args.snapshot_dir, args.prefix)
def main():
print(config)
cudnn.enabled = True
torch.manual_seed(random_seed)
torch.cuda.manual_seed(random_seed)
np.random.seed(random_seed)
random.seed(random_seed)
torch.backends.cudnn.deterministic = True
if pretraining == 'COCO':
from utils.transformsgpu import normalize_bgr as normalize
else:
from utils.transformsgpu import normalize_rgb as normalize
batch_size_unlabeled = int(batch_size / 2)
batch_size_labeled = int(batch_size * 1)
RAMP_UP_ITERS = 2000
data_loader = get_loader('cityscapes')
data_path = get_data_path('cityscapes')
data_aug = Compose([
RandomCrop_city(input_size)
]) # from 1024x2048 to resize 512x1024 to crop input_size (512x512)
train_dataset = data_loader(data_path,
is_transform=True,
augmentations=data_aug,
img_size=input_size,
pretraining=pretraining)
from data.gta5_loader import gtaLoader
data_loader_gta = gtaLoader
data_path_gta = get_data_path('gta5')
data_aug_gta = Compose([
RandomCrop_city(input_size)
]) # from 1024x2048 to resize 512x1024 to crop input_size (512x512)
train_dataset_gta = data_loader_gta(data_path_gta,
is_transform=True,
augmentations=data_aug_gta,
img_size=input_size,
pretraining=pretraining)
train_dataset_size = len(train_dataset)
print('dataset size: ', train_dataset_size)
partial_size = labeled_samples
print('Training on number of samples:', partial_size)
class_weights_curr = ClassBalancing(
labeled_iters=int(labeled_samples / batch_size_labeled),
unlabeled_iters=int(
(train_dataset_size - labeled_samples) / batch_size_unlabeled),
n_classes=num_classes)
feature_memory = FeatureMemory(num_samples=labeled_samples,
dataset=dataset,
memory_per_class=256,
feature_size=256,
n_classes=num_classes)
# select the partition
if split_id is not None:
train_ids = pickle.load(open(split_id, 'rb'))
print('loading train ids from {}'.format(split_id))
else:
train_ids = np.arange(train_dataset_size)
np.random.shuffle(train_ids)
train_sampler = data.sampler.SubsetRandomSampler(train_ids[:partial_size])
trainloader = data.DataLoader(train_dataset,
batch_size=batch_size_labeled,
sampler=train_sampler,
num_workers=num_workers,
pin_memory=True)
trainloader_iter = iter(trainloader)
# GTA5
train_ids_gta = np.arange(len(train_dataset_gta))
np.random.shuffle(train_ids_gta)
train_sampler_gta = data.sampler.SubsetRandomSampler(train_ids_gta)
trainloader_gta = data.DataLoader(train_dataset_gta,
batch_size=batch_size_labeled,
sampler=train_sampler_gta,
num_workers=num_workers,
pin_memory=True)
trainloader_iter_gta = iter(trainloader_gta)
train_remain_sampler = data.sampler.SubsetRandomSampler(
train_ids[partial_size:])
trainloader_remain = data.DataLoader(train_dataset,
batch_size=batch_size_unlabeled,
sampler=train_remain_sampler,
num_workers=num_workers,
pin_memory=True)
trainloader_remain_iter = iter(trainloader_remain)
# LOSSES
unlabeled_loss = CrossEntropyLoss2dPixelWiseWeighted().cuda()
supervised_loss = CrossEntropy2d(ignore_label=ignore_label).cuda()
''' Deeplab model '''
# Define network
if deeplabv2:
if pretraining == 'COCO': # coco and iamgenet resnet architectures differ a little, just on how to do the stride
from model.deeplabv2 import Res_Deeplab
else: # imagenet pretrained (more modern modification)
from model.deeplabv2_imagenet import Res_Deeplab
else:
from model.deeplabv3 import Res_Deeplab
# create network
model = Res_Deeplab(num_classes=num_classes)
# load pretrained parameters
if pretraining == 'COCO':
saved_state_dict = model_zoo.load_url(
'http://vllab1.ucmerced.edu/~whung/adv-semi-seg/resnet101COCO-41f33a49.pth'
) # COCO pretraining
else:
saved_state_dict = model_zoo.load_url(
'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth'
) # iamgenet pretrainning
# Copy loaded parameters to model
new_params = model.state_dict().copy()
for name, param in new_params.items():
if name in saved_state_dict and param.size(
) == saved_state_dict[name].size():
new_params[name].copy_(saved_state_dict[name])
model.load_state_dict(new_params)
# Optimizer for segmentation network
learning_rate_object = Learning_Rate_Object(
config['training']['learning_rate'])
optimizer = torch.optim.SGD(model.optim_parameters(learning_rate_object),
lr=learning_rate,
momentum=momentum,
weight_decay=weight_decay)
ema_model = create_ema_model(model, Res_Deeplab)
ema_model.train()
ema_model = ema_model.cuda()
model.train()
model = model.cuda()
cudnn.benchmark = True
# checkpoint = torch.load('/home/snowflake/Escritorio/Semi-Sup/saved/Deep_cont/best_model.pth')
# model.load_state_dict(checkpoint['model'])
if not os.path.exists(checkpoint_dir):
os.makedirs(checkpoint_dir)
with open(checkpoint_dir + '/config.json', 'w') as handle:
json.dump(config, handle, indent=4, sort_keys=False)
pickle.dump(train_ids,
open(os.path.join(checkpoint_dir, 'train_split.pkl'), 'wb'))
interp = nn.Upsample(size=(input_size[0], input_size[1]),
mode='bilinear',
align_corners=True)
epochs_since_start = 0
start_iteration = 0
best_mIoU = 0 # best metric while training
iters_without_improve = 0
# TRAINING
for i_iter in range(start_iteration, num_iterations):
model.train() # set mode to training
optimizer.zero_grad()
a = time.time()
loss_l_value = 0.
adjust_learning_rate(optimizer, i_iter)
''' LABELED SAMPLES '''
# Get batch
is_cityscapes = i_iter % 2 == 0
is_gta = not is_cityscapes
if num_iterations - i_iter > 100:
# Last 100 itereations only citysacpes data
is_cityscapes = True
if is_cityscapes:
try:
batch = next(trainloader_iter)
if batch[0].shape[0] != batch_size_labeled:
batch = next(trainloader_iter)
except: # finish epoch, rebuild the iterator
epochs_since_start = epochs_since_start + 1
# print('Epochs since start: ',epochs_since_start)
trainloader_iter = iter(trainloader)
batch = next(trainloader_iter)
else:
try:
batch = next(trainloader_iter_gta)
if batch[0].shape[0] != batch_size_labeled:
train_ids_gta = np.arange(len(train_dataset_gta))
np.random.shuffle(train_ids_gta)
train_sampler_gta = data.sampler.SubsetRandomSampler(
train_ids_gta)
trainloader_gta = data.DataLoader(
train_dataset_gta,
batch_size=batch_size_labeled,
sampler=train_sampler_gta,
num_workers=num_workers,
pin_memory=True)
trainloader_iter_gta = iter(trainloader_gta)
batch = next(trainloader_iter_gta)
except: # finish epoch, rebuild the iterator
# print('Epochs since start: ',epochs_since_start)
trainloader_iter_gta = iter(trainloader_gta)
batch = next(trainloader_iter_gta)
images, labels, _, _, _ = batch
images = images.cuda()
labels = labels.cuda()
''' UNLABELED SAMPLES '''
try:
batch_remain = next(trainloader_remain_iter)
if batch_remain[0].shape[0] != batch_size_unlabeled:
batch_remain = next(trainloader_remain_iter)
except:
trainloader_remain_iter = iter(trainloader_remain)
batch_remain = next(trainloader_remain_iter)
# Unlabeled
unlabeled_images, _, _, _, _ = batch_remain
unlabeled_images = unlabeled_images.cuda()
# Create pseudolabels
with torch.no_grad():
if use_teacher:
logits_u_w, features_weak_unlabeled = ema_model(
normalize(unlabeled_images, dataset), return_features=True)
else:
model.eval()
logits_u_w, features_weak_unlabeled = model(
normalize(unlabeled_images, dataset), return_features=True)
logits_u_w = interp(logits_u_w).detach() # prediction unlabeled
softmax_u_w = torch.softmax(logits_u_w, dim=1)
max_probs, pseudo_label = torch.max(softmax_u_w,
dim=1) # Get pseudolabels
model.train()
if is_cityscapes:
class_weights_curr.add_frequencies(labels.cpu().numpy(),
pseudo_label.cpu().numpy())
images2, labels2, _, _ = augment_samples(images,
labels,
None,
random.random() < 0.25,
batch_size_labeled,
ignore_label,
weak=True)
'''
UNLABELED DATA
'''
'''
CROSS ENTROPY FOR UNLABELED USING PSEUDOLABELS
Once you have the speudolabel, perform strong augmetnation to force the netowrk to yield lower confidence scores for pushing them up
'''
do_classmix = i_iter > RAMP_UP_ITERS and random.random(
) < 0.75 # only after rampup perfrom classmix
unlabeled_images_aug1, pseudo_label1, max_probs1, unlabeled_aug1_params = augment_samples(
unlabeled_images, pseudo_label, max_probs, do_classmix,
batch_size_unlabeled, ignore_label)
do_classmix = i_iter > RAMP_UP_ITERS and random.random(
) < 0.75 # only after rampup perfrom classmix
unlabeled_images_aug2, pseudo_label2, max_probs2, unlabeled_aug2_params = augment_samples(
unlabeled_images, pseudo_label, max_probs, do_classmix,
batch_size_unlabeled, ignore_label)
joined_unlabeled = torch.cat(
(unlabeled_images_aug1, unlabeled_images_aug2), dim=0)
joined_pseudolabels = torch.cat((pseudo_label1, pseudo_label2), dim=0)
joined_maxprobs = torch.cat((max_probs1, max_probs2), dim=0)
pred_joined_unlabeled, features_joined_unlabeled = model(
normalize(joined_unlabeled, dataset), return_features=True)
pred_joined_unlabeled = interp(pred_joined_unlabeled)
joined_labeled = images2
joined_labels = labels2
labeled_pred, labeled_features = model(normalize(
joined_labeled, dataset),
return_features=True)
labeled_pred = interp(labeled_pred)
class_weights = torch.from_numpy(np.ones((num_classes))).cuda()
if i_iter > RAMP_UP_ITERS:
class_weights = torch.from_numpy(
class_weights_curr.get_weights(num_iterations,
only_labeled=False)).cuda()
loss = 0
# SUPERVISED SEGMENTATION
labeled_loss = supervised_loss(labeled_pred,
joined_labels,
weight=class_weights.float()) #
loss = loss + labeled_loss
# SELF-SUPERVISED SEGMENTATION
'''
Cross entropy loss using pseudolabels.
'''
unlabeled_loss = CrossEntropyLoss2dPixelWiseWeighted(
ignore_index=ignore_label, weight=class_weights.float()).cuda() #
# Pseudo-label weighting
pixelWiseWeight = sigmoid_ramp_up(i_iter, RAMP_UP_ITERS) * torch.ones(
joined_maxprobs.shape).cuda()
pixelWiseWeight = pixelWiseWeight * torch.pow(joined_maxprobs.detach(),
6)
# Pseudo-label loss
loss_ce_unlabeled = unlabeled_loss(pred_joined_unlabeled,
joined_pseudolabels,
pixelWiseWeight)
loss = loss + loss_ce_unlabeled
# entropy loss
valid_mask = (joined_pseudolabels != ignore_label).unsqueeze(1)
loss = loss + entropy_loss(
torch.nn.functional.softmax(pred_joined_unlabeled, dim=1),
valid_mask) * 0.01
# CONTRASTIVE LEARNING
if is_cityscapes:
if i_iter > RAMP_UP_ITERS - 1000:
# Build Memory Bank 1000 iters before starting to do contrsative
with torch.no_grad():
if use_teacher:
labeled_pred_ema, labeled_features_ema = ema_model(
normalize(joined_labeled, dataset),
return_features=True)
else:
model.eval()
labeled_pred_ema, labeled_features_ema = model(
normalize(joined_labeled, dataset),
return_features=True)
model.train()
labeled_pred_ema = interp(labeled_pred_ema)
probability_prediction_ema, label_prediction_ema = torch.max(
torch.softmax(labeled_pred_ema,
dim=1), dim=1) # Get pseudolabels
labels_down = nn.functional.interpolate(
joined_labels.float().unsqueeze(1),
size=(labeled_features_ema.shape[2],
labeled_features_ema.shape[3]),
mode='nearest').squeeze(1)
label_prediction_down = nn.functional.interpolate(
label_prediction_ema.float().unsqueeze(1),
size=(labeled_features_ema.shape[2],
labeled_features_ema.shape[3]),
mode='nearest').squeeze(1)
probability_prediction_down = nn.functional.interpolate(
probability_prediction_ema.float().unsqueeze(1),
size=(labeled_features_ema.shape[2],
labeled_features_ema.shape[3]),
mode='nearest').squeeze(1)
# get mask where the labeled predictions are correct
mask_prediction_correctly = (
(label_prediction_down == labels_down).float() *
(probability_prediction_down > 0.95).float()).bool()
labeled_features_correct = labeled_features_ema.permute(
0, 2, 3, 1)
labels_down_correct = labels_down[mask_prediction_correctly]
labeled_features_correct = labeled_features_correct[
mask_prediction_correctly, ...]
# get projected features
with torch.no_grad():
if use_teacher:
proj_labeled_features_correct = ema_model.projection_head(
labeled_features_correct)
else:
model.eval()
proj_labeled_features_correct = model.projection_head(
labeled_features_correct)
model.train()
# updated memory bank
feature_memory.add_features_from_sample_learned(
ema_model, proj_labeled_features_correct,
labels_down_correct, batch_size_labeled)
if i_iter > RAMP_UP_ITERS:
'''
LABELED TO LABELED. Force features from laeled samples, to be similar to other features from the same class (which also leads to good predictions)
'''
# now we can take all. as they are not the prototypes, here we are gonan force these features to be similar as the correct ones
mask_prediction_correctly = (labels_down != ignore_label)
labeled_features_all = labeled_features.permute(0, 2, 3, 1)
labels_down_all = labels_down[mask_prediction_correctly]
labeled_features_all = labeled_features_all[
mask_prediction_correctly, ...]
# get prediction features
proj_labeled_features_all = model.projection_head(
labeled_features_all)
pred_labeled_features_all = model.prediction_head(
proj_labeled_features_all)
loss_contr_labeled = contrastive_class_to_class_learned_memory(
model, pred_labeled_features_all, labels_down_all, num_classes,
feature_memory.memory)
loss = loss + loss_contr_labeled * 0.2
'''
CONTRASTIVE LEARNING ON UNLABELED DATA. align unlabeled features to labeled features
'''
joined_pseudolabels_down = nn.functional.interpolate(
joined_pseudolabels.float().unsqueeze(1),
size=(features_joined_unlabeled.shape[2],
features_joined_unlabeled.shape[3]),
mode='nearest').squeeze(1)
# take out the features from black pixels from zooms out and augmetnations (ignore labels on pseduoalebl)
mask = (joined_pseudolabels_down != ignore_label)
features_joined_unlabeled = features_joined_unlabeled.permute(
0, 2, 3, 1)
features_joined_unlabeled = features_joined_unlabeled[mask, ...]
joined_pseudolabels_down = joined_pseudolabels_down[mask]
# get projected features
proj_feat_unlabeled = model.projection_head(
features_joined_unlabeled)
pred_feat_unlabeled = model.prediction_head(proj_feat_unlabeled)
loss_contr_unlabeled = contrastive_class_to_class_learned_memory(
model, pred_feat_unlabeled, joined_pseudolabels_down,
num_classes, feature_memory.memory)
loss = loss + loss_contr_unlabeled * 0.2
loss_l_value += loss.item()
# optimize
loss.backward()
optimizer.step()
m = 1 - (1 - 0.995) * (math.cos(math.pi * i_iter / num_iterations) +
1) / 2
ema_model = update_ema_variables(ema_model=ema_model,
model=model,
alpha_teacher=m,
iteration=i_iter)
# print('iter = {0:6d}/{1:6d}, loss_l = {2:.3f}'.format(i_iter, num_iterations, loss_l_value))
if i_iter % save_checkpoint_every == 0 and i_iter != 0:
_save_checkpoint(i_iter, model, optimizer, config)
if i_iter % val_per_iter == 0 and i_iter != 0:
print('iter = {0:6d}/{1:6d}'.format(i_iter, num_iterations))
model.eval()
mIoU, eval_loss = evaluate(model,
dataset,
ignore_label=ignore_label,
save_dir=checkpoint_dir,
pretraining=pretraining)
model.train()
if mIoU > best_mIoU:
best_mIoU = mIoU
if save_teacher:
_save_checkpoint(i_iter,
ema_model,
optimizer,
config,
save_best=True)
else:
_save_checkpoint(i_iter,
model,
optimizer,
config,
save_best=True)
iters_without_improve = 0
else:
iters_without_improve += val_per_iter
'''
if the performance has not improve in N iterations, try to reload best model to optimize again with a lower LR
Simulating an iterative training'''
if iters_without_improve > num_iterations / 5.:
print('Re-loading a previous best model')
checkpoint = torch.load(
os.path.join(checkpoint_dir, f'best_model.pth'))
model.load_state_dict(checkpoint['model'])
ema_model = create_ema_model(model, Res_Deeplab)
ema_model.train()
ema_model = ema_model.cuda()
model.train()
model = model.cuda()
iters_without_improve = 0 # reset timer
_save_checkpoint(num_iterations, model, optimizer, config)
# FINISH TRAINING, evaluate again
model.eval()
mIoU, eval_loss = evaluate(model,
dataset,
deeplabv2=deeplabv2,
ignore_label=ignore_label,
save_dir=checkpoint_dir,
pretraining=pretraining)
model.train()
if mIoU > best_mIoU and save_best_model:
best_mIoU = mIoU
_save_checkpoint(i_iter, model, optimizer, config, save_best=True)
# TRY IMPROVING BEST MODEL WITH EMA MODEL OR UPDATING BN STATS
# Load best model
checkpoint = torch.load(os.path.join(checkpoint_dir, f'best_model.pth'))
model.load_state_dict(checkpoint['model'])
model = model.cuda()
model = update_BN_weak_unlabeled_data(model, normalize,
batch_size_unlabeled,
trainloader_remain)
model.eval()
mIoU, eval_loss = evaluate(model,
dataset,
deeplabv2=deeplabv2,
ignore_label=ignore_label,
save_dir=checkpoint_dir,
pretraining=pretraining)
model.train()
if mIoU > best_mIoU and save_best_model:
best_mIoU = mIoU
_save_checkpoint(i_iter, model, optimizer, config, save_best=True)
print('BEST MIOU')
print(max(best_mIoU_improved, best_mIoU))
end = timeit.default_timer()
print('Total time: ' + str(end - start) + ' seconds')
def evaluate(model,
dataset,
deeplabv2=True,
ignore_label=250,
save_dir=None,
pretraining='COCO'):
model.eval()
if pretraining == 'COCO':
from utils.transformsgpu import normalize_bgr as normalize
else:
from utils.transformsgpu import normalize_rgb as normalize
if dataset == 'pascal_voc':
num_classes = 21
data_loader = get_loader(dataset)
data_path = get_data_path(dataset)
test_dataset = data_loader(data_path,
split="val",
scale=False,
mirror=False,
pretraining=pretraining)
testloader = data.DataLoader(test_dataset,
batch_size=1,
shuffle=False,
pin_memory=True)
elif dataset == 'cityscapes':
num_classes = 19
data_loader = get_loader('cityscapes')
data_path = get_data_path('cityscapes')
if deeplabv2:
data_aug = Compose([Resize_city()])
else: # for deeplabv3 oirginal resolution
data_aug = Compose([Resize_city_highres()])
test_dataset = data_loader(data_path,
is_transform=True,
split='val',
augmentations=data_aug,
pretraining=pretraining)
testloader = data.DataLoader(test_dataset,
batch_size=1,
shuffle=False,
pin_memory=True)
print('Evaluating, found ' + str(len(testloader)) + ' images.')
confM = ConfusionMatrix(num_classes)
data_list = []
total_loss = []
for index, batch in enumerate(testloader):
image, label, size, name, _ = batch
with torch.no_grad():
interp = torch.nn.Upsample(size=(label.shape[1], label.shape[2]),
mode='bilinear',
align_corners=True)
output = model(normalize(Variable(image).cuda(), dataset))
output = interp(output)
label_cuda = Variable(label.long()).cuda()
criterion = CrossEntropy2d(ignore_label=ignore_label).cuda()
loss = criterion(output, label_cuda)
total_loss.append(loss.item())
output = output.cpu().data[0].numpy()
gt = np.asarray(label[0].numpy(), dtype=np.int)
output = np.asarray(np.argmax(output, axis=0), dtype=np.int)
data_list.append((np.reshape(gt, (-1)), np.reshape(output, (-1))))
# filename = 'output_images/' + name[0].split('/')[-1]
# cv2.imwrite(filename, output)
if (index + 1) % 100 == 0:
# print('%d processed' % (index + 1))
process_list_evaluation(confM, data_list)
data_list = []
process_list_evaluation(confM, data_list)
mIoU = get_iou(confM, dataset)
loss = np.mean(total_loss)
return mIoU, loss
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
print_info(
'----------------------------------------------------------------------\n'
'| M2Det Training Program |\n'
'----------------------------------------------------------------------',
['yellow', 'bold'])
# logger = set_logger(status=True)
net = LinkNet(n_classes=2)
# net = SegNet()
# net = unet(n_classes=2)
# net = DeepLab(backbone='mobilenet', output_stride=16)
# net = DeepLab(backbone='resnet', output_stride=16)
# net = DeepLab(backbone='xception', output_stride=16)
bce_loss = CrossEntropy2d()
# cudnn.ben
# summary(net, (3, 512, 512))
optimizer = optim.Adam(net.parameters())
net.train()
net.cuda(0)
epoch = C.NUM_EPOCHS
print_info('===> Loading Dataset...', ['yellow', 'bold'])
_preproc = preproc(C.TRAIN_SCALES[0], C.RGB_MEAM, C.P)
_AnnoTrans = AnnotationTransform()
traindataloader = RoadDetection(data_path=C.DATA_PATH_TRAIN,
seg_file=C.TRAIN_ROI_FILE,
preproc=_preproc,
target_transform=_AnnoTrans,