def validate(model, data_loader):
print('\nvalidating ... ', flush=True, end='')
val_loss_meter = pyutils.AverageMeter('loss')
val_loss_metersub = pyutils.AverageMeter('losssub')
model.eval()
with torch.no_grad():
for pack in data_loader:
img = pack[1]
label = pack[2].cuda(non_blocking=True)
xf, x, xsub = model(img)
loss = F.multilabel_soft_margin_loss(x, label)
val_loss_meter.add({'loss': loss.item()})
# losssub = F.multilabel_soft_margin_loss(xsub, labelssubi)
# val_loss_metersub.add({'losssub': losssub.item()})
model.train()
print('loss:', val_loss_meter.pop('loss'))
return
def validate(model, data_loader):
print('\nvalidating ... ', flush=True, end='')
val_loss_meter = pyutils.AverageMeter('loss')
model.eval()
with torch.no_grad():
for pack in data_loader:
img = pack[1]
label = pack[2].cuda(non_blocking=True)
x = model(img, require_seg=False, require_mcam=False)
loss = F.multilabel_soft_margin_loss(x, label)
val_loss_meter.add({'loss': loss.item()})
model.train()
print('loss:', val_loss_meter.pop('loss'))
return
def validate(model, data_loader):
print('\nvalidating ... ', flush=True, end='')
val_loss_meter = pyutils.AverageMeter('loss')
model.eval()
with torch.no_grad():
for pack in data_loader:
img = pack[1]
label = pack[2].cuda(non_blocking=True)
label = label.unsqueeze(2).unsqueeze(3)
x = model(img)
x = F.adaptive_avg_pool2d(x, (1,1))
loss = F.multilabel_soft_margin_loss(x, label)
val_loss_meter.add({'loss': loss.item()})
model.train()
print('loss:', val_loss_meter.pop('loss'))
return
weight_decay=args.wt_dec,
max_step=max_step)
if args.weights[-7:] == '.params':
import network.resnet38d
assert 'resnet38' in args.network
weights_dict = network.resnet38d.convert_mxnet_to_torch(args.weights)
else:
weights_dict = torch.load(args.weights)
model.load_state_dict(weights_dict, strict=False)
model = torch.nn.DataParallel(model).cuda()
model.train()
avg_meter = pyutils.AverageMeter('loss', 'loss_cls', 'loss_er', 'loss_ecr')
timer = pyutils.Timer("Session started: ")
for ep in range(args.max_epoches):
for iter, pack in enumerate(train_data_loader):
scale_factor = 0.3
img1 = pack[1]
img2 = F.interpolate(img1,
scale_factor=scale_factor,
mode='bilinear',
align_corners=True)
N, C, H, W = img1.size()
label = pack[2]
bg_score = torch.ones((N, 1))
if args.weights[-7:] == '.params':
import network.resnet38d
assert args.network == "network.resnet38_aff"
weights_dict = network.resnet38d.convert_mxnet_to_torch(args.weights)
elif args.weights[-11:] == '.caffemodel':
import network.vgg16d
assert args.network == "network.vgg16_aff"
weights_dict = network.vgg16d.convert_caffe_to_torch(args.weights)
else:
weights_dict = torch.load(args.weights)
model.load_state_dict(weights_dict, strict=False)
model = torch.nn.DataParallel(model).cuda()
model.train()
avg_meter = pyutils.AverageMeter('loss', 'bg_loss', 'fg_loss', 'neg_loss',
'bg_cnt', 'fg_cnt', 'neg_cnt')
timer = pyutils.Timer("Session started: ")
for ep in range(args.max_epoches):
for iter, pack in enumerate(train_data_loader):
aff = model.forward(pack[0])
bg_label = pack[1][0].cuda(non_blocking=True)
fg_label = pack[1][1].cuda(non_blocking=True)
neg_label = pack[1][2].cuda(non_blocking=True)
bg_count = torch.sum(bg_label) + 1e-5
fg_count = torch.sum(fg_label) + 1e-5
if args.weights[-7:] == '.params':
assert args.network == "network.resnet38_cls"
import network.resnet38d
weights_dict = network.resnet38d.convert_mxnet_to_torch(args.weights)
elif args.weights[-11:] == '.caffemodel':
assert args.network == "network.vgg16_cls"
import network.vgg16d
weights_dict = network.vgg16d.convert_caffe_to_torch(args.weights)
else:
weights_dict = torch.load(args.weights)
model.load_state_dict(weights_dict, strict=False)
model = torch.nn.DataParallel(model).cuda()
model.train()
avg_meter = pyutils.AverageMeter('loss')
timer = pyutils.Timer("Session started: ")
for ep in range(args.max_epoches):
for iter, pack in enumerate(train_data_loader):
img = pack[1]
label = pack[2].cuda(non_blocking=True)
x = model(img)
loss = F.multilabel_soft_margin_loss(x, label)
avg_meter.add({'loss': loss.item()})
weights_dict = network.resnet38d.convert_mxnet_to_torch(args.weights)
elif args.weights[-11:] == '.caffemodel':
assert args.network == "network.vgg16_cls" or "network.vgg16_subcls"
import network.vgg16d
weights_dict = network.vgg16d.convert_caffe_to_torch(args.weights)
torch.save(weights_dict,'vgg16_20M.pth')
else:
weights_dict = torch.load(args.weights)
# del weights_dict['fc8.weight']
# print(type(weights_dict), weights_dict.keys())
model.load_state_dict(weights_dict, strict=False)
model = torch.nn.DataParallel(model).cuda()
model.train()
avg_meter = pyutils.AverageMeter('loss')
avg_metersub = pyutils.AverageMeter('losssub')
timer = pyutils.Timer("Session started: ")
channel=model.module.dim[0]
n_cluster=10
centers = torch.zeros((20, n_cluster, channel))
cneterready = torch.zeros((20,))
for j in range(3):
optimizer = torchutils.PolyOptimizer([
{'params': param_groups[0], 'lr': args.lr, 'weight_decay': args.wt_dec},
{'params': param_groups[1], 'lr': 2 * args.lr, 'weight_decay': 0},
{'params': param_groups[2], 'lr': 10 * args.lr, 'weight_decay': args.wt_dec},
{'params': param_groups[3], 'lr': 20 * args.lr, 'weight_decay': 0}
], lr=args.lr, weight_decay=args.wt_dec, max_step=max_step)
if args.weights[-7:] == '.params':
assert args.network == "network.resnet38_cls_ser"
import network.resnet38d
weights_dict = network.resnet38d.convert_mxnet_to_torch(args.weights)
elif args.weights[-11:] == '.caffemodel':
assert args.network == "network.vgg16_cls_ser"
import network.vgg16d
weights_dict = network.vgg16d.convert_caffe_to_torch(args.weights)
else:
weights_dict = torch.load(args.weights)
model.load_state_dict(weights_dict, strict=False)
model = torch.nn.DataParallel(model).cuda()
model.train()
avg_meter = pyutils.AverageMeter('loss','loss_cls','loss_cls_s','loss_r')
timer = pyutils.Timer("Session started: ")
for ep in range(args.max_epoches):
for iter, pack in enumerate(train_data_loader):
img = pack[1]
label = pack[2].cuda(non_blocking=True)
label = label.unsqueeze(2).unsqueeze(3)
cam = model(img)
N,C,H,W = cam.size()
predicts = F.adaptive_avg_pool2d(cam, (1,1))
loss_cls = F.multilabel_soft_margin_loss(predicts, label)
