def __init__(self, backbone='resnet101', n_classes=20, k_words=256):
super(Net, self).__init__()
if backbone == 'resnet50':
self.resnet = resnet.resnet50(pretrained=True,
strides=(2, 2, 2, 1))
elif backbone == 'resnet101':
self.resnet = resnet.resnet101(pretrained=True,
strides=(2, 2, 2, 1))
self.n_classes = n_classes
self.k_words = k_words
self.stage1 = nn.Sequential(self.resnet.conv1, self.resnet.bn1,
self.resnet.relu, self.resnet.maxpool,
self.resnet.layer1)
self.stage2 = nn.Sequential(self.resnet.layer2)
self.stage3 = nn.Sequential(self.resnet.layer3)
self.stage4 = nn.Sequential(self.resnet.layer4)
self.classifier = nn.Conv2d(2048, self.n_classes, 1, bias=False)
self.fc_a = nn.Conv2d(self.k_words, self.n_classes, 1, bias=False)
self.fc_b = nn.Conv2d(2048, self.k_words, 1, bias=False)
self.VWE = VWE(k_words=self.k_words)
self.backbone = nn.ModuleList(
[self.stage1, self.stage2, self.stage3, self.stage4])
self.newly_added = nn.ModuleList(
[self.classifier, self.VWE, self.fc_a, self.fc_b])
def __init__(self, num_classes, arg, pretrained=True):
super(TubeTK, self).__init__()
self.arg = arg
if arg.backbone == 'res50':
self.backbone = resnet50(freeze_stages=arg.freeze_stages,
fst_l_stride=arg.model_stride[0][0])
elif arg.backbone == 'res101':
self.backbone = resnet101(freeze_stages=arg.freeze_stages,
fst_l_stride=arg.model_stride[0][0])
elif arg.backbone == 'resx101':
self.backbone = resnext101(freeze_stages=arg.freeze_stages,
fst_l_stride=arg.model_stride[0][0])
else:
raise NotImplementedError
self.neck = FPN(in_channels=[512, 1024, 2048], arg=arg)
self.tube_head = TrackHead(
arg=arg,
num_classes=num_classes,
in_channels=self.neck.out_channels,
strides=[[
arg.model_stride[i][0] / (arg.forward_frames * 2) *
arg.value_range,
arg.model_stride[i][1] / arg.img_size[0] * arg.value_range,
arg.model_stride[i][1] / arg.img_size[1] * arg.value_range
] for i in range(5)])
if pretrained and arg.pretrain_model_path != '':
self.load_pretrain(model_path=arg.pretrain_model_path)
torch.cuda.empty_cache()
def __init__(self, trunk_name, output_stride=8, pretrained=True):
super(get_resnet, self).__init__()
if trunk_name == "resnet18":
resnet = resnet18(pretrained=pretrained)
resnet.layer0 = nn.Sequential(resnet.conv1, resnet.bn1,
resnet.relu, resnet.maxpool)
elif trunk_name == "resnet34":
resnet = resnet34(pretrained=pretrained)
resnet.layer0 = nn.Sequential(resnet.conv1, resnet.bn1,
resnet.relu, resnet.maxpool)
elif trunk_name == "resnet50":
resnet = resnet50(pretrained=pretrained)
resnet.layer0 = nn.Sequential(resnet.conv1, resnet.bn1,
resnet.relu, resnet.maxpool)
elif trunk_name == "resnet101":
resnet = resnet101(pretrained=pretrained)
resnet.layer0 = nn.Sequential(resnet.conv1, resnet.bn1,
resnet.relu, resnet.maxpool)
elif trunk_name == "resnet152":
resnet = resnet152(pretrained=pretrained)
resnet.layer0 = nn.Sequential(resnet.conv1, resnet.bn1,
resnet.relu, resnet.maxpool)
elif trunk_name == "resnext101_32x8d":
resnet = resnext101_32x8d(pretrained=pretrained)
resnet.layer0 = nn.Sequential(resnet.conv1, resnet.bn1,
resnet.relu, resnet.maxpool)
elif trunk_name == "se_resnet50":
resnet = se_resnext50_32x4d(pretrained=pretrained)
elif trunk_name == "se_resnet101":
resnet = se_resnext101_32x4d(pretrained=pretrained)
else:
raise KeyError("[*] Not a valid network arch")
self.layer0 = resnet.layer0
self.layer1, self.layer2, self.layer3, self.layer4 = \
resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4
if output_stride == 8:
for n, m in self.layer3.named_modules():
if 'conv2' in n:
m.dilation, m.padding, m.stride = (2, 2), (2, 2), (1, 1)
elif 'downsample.0' in n:
m.stride = (1, 1)
for n, m in self.layer4.named_modules():
if 'conv2' in n:
m.dilation, m.padding, m.stride = (4, 4), (4, 4), (1, 1)
elif 'downsample.0' in n:
m.stride = (1, 1)
elif output_stride == 16:
for n, m in self.layer4.named_modules():
if 'conv2' in n:
m.dilation, m.padding, m.stride = (2, 2), (2, 2), (1, 1)
elif 'downsample.0' in n:
m.stride = (1, 1)
else:
raise KeyError(
"[*] Unsupported output_stride {}".format(output_stride))
def __init__(self, num_classes=256, input_bits=8, embed_dim=8, seq_len=100, backbone='resnet50'):
super(CNN, self).__init__()
self.input_bits = input_bits
self.seq_len = seq_len
# self.embed = nn.Embedding(256, 256)
self.embed = nn.Embedding(2 ** input_bits, embed_dim)
self.backbone = {
'resnet18': resnet18(n_classes=num_classes, input_channels=embed_dim),
'resnet34': resnet34(n_classes=num_classes, input_channels=embed_dim),
'resnet50': resnet50(n_classes=num_classes, input_channels=embed_dim),
'resnet101': resnet101(n_classes=num_classes, input_channels=embed_dim),
'resnet152': resnet152(n_classes=num_classes, input_channels=embed_dim),
}.get(backbone, 'resnet50')
def test_ensemble(self, epochs=99):
pth = self.args.ensemble
cnt = len(pth)
print(f'>>>>>>>>>>>ensemble {cnt} model<<<<<<<<<<<<<')
net = []
for i in range(cnt):
net.append(resnet.resnet50(num_classes=self.args.num_classes))
for i in range(cnt):
print(pth[i])
net[i].load_state_dict(torch.load(pth[i]), strict=True)
for i in range(cnt):
net[i].cuda()
net[i].eval()
dataset = DataSet(self.args.img_path, self.args.img_txt_test, self.test_transform)
val_loader = DataLoader(dataset, batch_size=32, shuffle=False, num_workers=8)
top1 = AvgMeter()
top5 = AvgMeter()
with torch.no_grad():
for i, (input, target) in enumerate(val_loader):
input = input.cuda(non_blocking=True)
target = target.cuda(non_blocking=True)
target = target.squeeze(1)
# compute output
output = net[0](input)
output = torch.softmax(output, dim=1)
for k in range(1, cnt):
output += torch.softmax(net[k](input), dim=1)
# measure accuracy and record loss
acc1, acc5 = accuracy(output, target, topk=(1, 5))
top1.update(acc1[0], input.size(0))
top5.update(acc5[0], input.size(0))
if i % self.args.print_freq == 0:
print('Test: [{0}/{1}]\t'
'Acc@1 {top1.val:.3f} ({top1.avg:.3f})\t'
'Acc@5 {top5.val:.3f} ({top5.avg:.3f})'.format(
i, len(val_loader), top1=top1, top5=top5))
print(' * Acc@1 {top1.avg:.3f} Acc@5 {top5.avg:.3f}'
.format(top1=top1, top5=top5))
print(f'Top-1 ACC: {top1.avg}, Top-5 ACC: {top5.avg}')
def __init__(self, args, train_transform=None, test_transform=None, val_transform=None):
self.args = args
self.train_transform = train_transform
self.test_transform = test_transform
self.val_transform = val_transform
self.loss_lams = torch.zeros(args.num_classes, args.num_classes, dtype=torch.float32).cuda()
self.loss_lams[:, :] = 1. / args.num_classes
self.loss_lams.requires_grad = False
if self.args.arch == 'resnet50':
self.net = resnet.resnet50(num_classes=args.num_classes)
elif self.args.arch == 'res2net50':
self.net = res2net.res2net50_26w_4s(num_classes=args.num_classes)
elif self.args.arch == 'resnet101':
self.net = resnet.resnet101()
elif self.args.arch == 'resnet18':
self.net = resnet.resnet18()
elif self.args.arch == 'resnet34':
self.net = resnet.resnet34()
elif self.args.arch == 'vgg16':
self.net = vgg_cub.vgg16()
elif self.args.arch == 'vgg16_bn':
self.net = vgg_cub.vgg16_bn()
elif self.args.arch == 'vgg19':
self.net = vgg_cub.vgg19()
elif self.args.arch == 'vgg19_bn':
self.net = vgg_cub.vgg19_bn()
elif self.args.arch == 'vgg16_std':
self.net = vgg_std.vgg16()
elif self.args.arch == 'vgg16_bn_std':
self.net = vgg_std.vgg16_bn()
elif self.args.arch == 'mobilenetv2':
self.net = mobilenetv2.mobilenet_v2(num_classes=args.num_classes)
if self.args.load_model is not None:
self.net.load_state_dict(torch.load(self.args.load_model), strict=True)
print('load model from %s' % self.args.load_model)
elif self.args.pretrained_model is not None:
self.net.load_state_dict(torch.load(self.args.pretrained_model), strict=False)
print('load pretrained model form %s' % self.args.pretrained_model)
else:
print('not load any model, will train from scrach!')
if args.expname is None:
args.expname = 'runs/{}_{}_{}'.format(args.arch, args.dataset, args.method)
os.makedirs(args.expname, exist_ok=True)
def create_model(Model, num_classes):
if Model == "ResNet18":
model = resnet18(pretrained=False)
fc_features = model.fc.in_features
model.fc = nn.Linear(fc_features, num_classes)
model = model.cuda()
elif Model == "ResNet34":
model = resnet34(pretrained=False).cuda()
fc_features = model.fc.in_features
model.fc = nn.Linear(fc_features, num_classes)
model = model.cuda()
elif Model == "ResNet50":
model = resnet50(pretrained=False).cuda()
fc_features = model.fc.in_features
model.fc = nn.Linear(fc_features, num_classes)
model = model.cuda()
elif Model == "ResNet101":
model = resnet101(pretrained=False).cuda()
fc_features = model.fc.in_features
model.fc = nn.Linear(fc_features, num_classes)
model = model.cuda()
elif Model == "MobileNet_v2":
model = mobilenet_v2(num_classes=num_classes, pretrained=False).cuda()
elif Model == "Mobilenetv3":
model = mobilenetv3(n_class=num_classes, pretrained=False).cuda()
elif Model == "shufflenet_v2_x0_5":
model = shufflenet_v2_x0_5(pretrained=False,
num_classes=num_classes).cuda()
elif Model == "shufflenet_v2_x1_0":
model = shufflenet_v2_x1_0(pretrained=False,
num_classes=num_classes).cuda()
elif Model == "shufflenet_v2_x1_5":
model = shufflenet_v2_x1_5(pretrained=False,
num_classes=num_classes).cuda()
elif Model == "shufflenet_v2_x1_5":
model = shufflenet_v2_x2_0(pretrained=False,
num_classes=num_classes).cuda()
elif "efficientnet" in Model:
model = EfficientNet.from_pretrained(Model,
num_classes=num_classes,
pretrained=False).cuda()
elif Model == "inception_v3":
model = inception_v3(pretrained=False, num_classes=num_classes).cuda()
elif Model == "mnasnet0_5":
model = mnasnet0_5(pretrained=False, num_classes=num_classes).cuda()
elif Model == "vgg11":
model = vgg11(pretrained=False, num_classes=num_classes).cuda()
elif Model == "vgg11_bn":
model = vgg11_bn(pretrained=False, num_classes=num_classes).cuda()
elif Model == "vgg19":
model = vgg19(pretrained=False, num_classes=num_classes).cuda()
elif Model == "densenet121":
model = densenet121(pretrained=False).cuda()
elif Model == "ResNeXt29_32x4d":
model = ResNeXt29_32x4d(num_classes=num_classes).cuda()
elif Model == "ResNeXt29_2x64d":
model = ResNeXt29_2x64d(num_classes=num_classes).cuda()
else:
print("model error")
# input = torch.randn(1, 3, 32, 32).cuda()
# flops, params = profile(model, inputs=(input,))
# flops, params = clever_format([flops, params], "%.3f")
# print("------------------------------------------------------------------------")
# print(" ",Model)
# print( " flops:", flops, " params:", params)
# print("------------------------------------------------------------------------")
return model
def main():
model_input_size = (224, 224)
batch_p = 32
batch_k = 3
loss_func = ep_loss
loss_name = loss_func.__name__
metric = 'euclidean'
margin = 0.2
beta = 1.2
orders = 2
embedding_dim = 128
model_name = 'resnet50_%d' % embedding_dim
train_iters = 130000
boundaries = [45000, 90000]
values = [1e-4, 1e-5, 1e-6]
num_warmup_steps = 1000
test_interval = 1000
val_iters = 200
test_iters = 100
display_iters = 10
save_iters = 5000
root_path = '/home/zlchen/dataset/deepfashion2_retrieval'
train_label_path = 'data/DeepFashionV2/train_label.txt'
val_label_path = 'data/DeepFashionV2/val_label.txt'
train_data = DataLoader('data/DeepFashionV2/train_set.txt',
model_input_size, batch_p, batch_k, True,
root_path, train_label_path)
image_batch, label_batch = train_data.get_batch()
val_data = DataLoader('data/DeepFashionV2/validation_set.txt',
model_input_size, batch_p, batch_k, False, root_path,
val_label_path)
# image_batch, label_batch = train_data.get_batch()
# test_data = DataLoader('data/DeepFashion/test.txt', model_input_size, batch_p, batch_k, False)
log_file = open('logs/log_{}_{}.txt'.format(model_name, loss_name), 'w')
with tf.Graph().as_default():
image_inputs = tf.placeholder(tf.float32,
shape=(None, *model_input_size, 3))
label_inputs = tf.placeholder(tf.int32, shape=(None, ))
is_training = tf.placeholder(dtype=tf.bool)
# fc_out = resnet.resnet50(image_inputs, is_training, embedding_dim)
# fc_out = resnet.resnet50(image_inputs, is_training, embedding_dim, orders=orders)
out, fc_out = resnet.resnet50(image_inputs,
is_training,
embedding_dim,
before_pool=True)
# dml_loss = loss_func.loss(fc_out, label_inputs, margin=margin, metric=metric)
# dml_loss = loss_func.loss(fc_out, label_inputs, lamb=margin, ms_mining=True)
dml_loss = loss_func.loss(fc_out, label_inputs)
# ho_loss = adv_loss.loss(fc_outs, is_training)
ho_loss = softmax_loss.loss(out, label_inputs)
loss = dml_loss + ho_loss
global_step = tf.Variable(0, name='global_step', trainable=False)
learning_rate = tf.train.piecewise_constant(x=global_step,
boundaries=boundaries,
values=values)
# warm up
# global_steps_int = tf.cast(global_step, tf.int32)
# warmup_steps_int = tf.constant(num_warmup_steps, dtype=tf.int32)
#
# global_steps_float = tf.cast(global_steps_int, tf.float32)
# warmup_steps_float = tf.cast(warmup_steps_int, tf.float32)
#
# warmup_percent_done = global_steps_float / warmup_steps_float
# warmup_learning_rate = values[0] * warmup_percent_done
#
# is_warmup = tf.cast(global_steps_int < warmup_steps_int, tf.float32)
# learning_rate = ((1.0 - is_warmup) * learning_rate + is_warmup * warmup_learning_rate)
# optimizer
# optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=0.9)
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops):
train_op = optimizer.minimize(loss, global_step=global_step)
tf_config = tf.ConfigProto()
tf_config.gpu_options.allow_growth = True
sess = tf.Session(config=tf_config)
sess.run(tf.global_variables_initializer())
print('model: {}'.format(model_name))
print('embedding_dim: {}'.format(embedding_dim))
print('loss name: {}'.format(loss_name))
print('metric: {}'.format(metric))
print('margin: {}'.format(margin))
# warn up
print('warm up')
image_batch = np.random.randn(batch_p * batch_k, *model_input_size, 3)
label_batch = np.random.randint(0, batch_p, (batch_p * batch_k, ))
sess.run(loss,
feed_dict={
image_inputs: image_batch,
label_inputs: label_batch,
is_training: False
})
# load pretrain
print('load pretrain model')
# load_weights(sess, 'weights/pretrain/c2s_attention/pretrain_c2s_attention.npy')
restore_variables = [
var for var in tf.trainable_variables()
if 'resnet_v2_50' in var.name
]
restore_saver = tf.train.Saver(var_list=restore_variables)
restore_saver.restore(
sess=sess, save_path='weights/pretrain/resnet50/resnet_v2_50.ckpt')
saver = tf.train.Saver()
print('training begein')
for train_iter in range(train_iters + 1):
if train_iter != 0 and train_iter % test_interval == 0:
# val
val_avg_loss = 0
for _ in range(val_iters):
image_batch, label_batch = val_data.get_batch()
loss_out = sess.run(dml_loss,
feed_dict={
image_inputs: image_batch,
label_inputs: label_batch,
is_training: False
})
val_avg_loss += loss_out
val_avg_loss /= val_iters
# # test
# test_avg_loss = 0
# for _ in range(test_iters):
# image_batch, label_batch = test_data.get_batch()
# loss_out = sess.run(loss, feed_dict={image_inputs: image_batch, label_inputs: label_batch, is_training: False})
# test_avg_loss += loss_out
# test_avg_loss /= test_iters
# print('train iter %d, val loss: %0.3f, test loss: %0.3f' % (train_iter, val_avg_loss, test_avg_loss), file=log_file, flush=True)
print('train iter %d, val loss: %0.3f' %
(train_iter, val_avg_loss),
file=log_file,
flush=True)
if train_iter != 0 and train_iter % save_iters == 0:
print('save model')
saver.save(sess,
'weights/{}_{}/checkpoint'.format(
model_name, loss_name),
global_step=global_step)
image_batch, label_batch = train_data.get_batch()
if train_iter != 0 and train_iter % display_iters == 0:
_, loss_out, dml_loss_out, ho_loss_out, train_lr = sess.run(
[train_op, loss, dml_loss, ho_loss, learning_rate],
feed_dict={
image_inputs: image_batch,
label_inputs: label_batch,
is_training: True
})
print(
'train iter %d, lr: %s, loss: %0.3f, dml_loss: %0.3f, ho_loss: %0.3f'
% (train_iter, train_lr, loss_out, dml_loss_out,
ho_loss_out),
file=log_file,
flush=True)
else:
sess.run(
[train_op, loss],
feed_dict={
image_inputs: image_batch,
label_inputs: label_batch,
is_training: True
})
log_file.close()
def train(config):
if not os.path.exists(config.model_path):
os.mkdir(config.model_path)
mean_img = [0.485, 0.456, 0.406]
std_img = [0.229, 0.224, 0.225]
# transforms.Resize((384, 300)),
transformations = transforms.Compose([
transforms.RandomResizedCrop(384, scale=(0.5, 2)),
# transforms.RandomCrop(384),
# transforms.ColorJitter(brightness=0.3, contrast=0.3, saturation=0.3, hue=0.1),
transforms.RandomHorizontalFlip(p=0.25),
# transforms.RandomRotation(25),
transforms.ToTensor(),
transforms.Normalize(mean=mean_img, std=std_img),
])
inv_normalize = transforms.Normalize(
mean=[
-mean_img[0] / std_img[0], -mean_img[1] / std_img[1],
-mean_img[2] / std_img[2]
],
std=[1 / std_img[0], 1 / std_img[1], 1 / std_img[2]])
dataset = AI_Dataset(mode='train', transform=transformations)
train_loader = torch.utils.data.DataLoader(
dataset=dataset,
batch_size=config.batch_size, # config.batch_size
num_workers=4, #
shuffle=True,
)
test_dataset = AI_Dataset(mode='val', transform=transformations)
test_loader = torch.utils.data.DataLoader(
dataset=test_dataset,
batch_size=1, # config.batch_size
num_workers=4, #
shuffle=False,
)
device = "cuda"
pretrained = False
resnet = resnet50(pretrained=True).cuda()
resnet.train()
# crit_bce = nn.BCEWithLogitsLoss().cuda() #weight=torch.FloatTensor([2]+[1]*3+[1]+[1]*16)
crit_bce = nn.BCEWithLogitsLoss().cuda(
) # weight=torch.FloatTensor([2]+[1]*3+[1]+[1]*16)
# opt_er = torch.optim.SGD(resnet_er.parameters(), lr=config.lr,momentum=0.9, weight_decay=5e-4,nesterov=False)
opt = torch.optim.Adam(resnet.parameters(),
lr=config.lr,
betas=(0.9, 0.999),
weight_decay=1e-5)
# min_loss = 999
best_acc = -999
torch.autograd.set_detect_anomaly(True)
print("START TRAINING")
loss_names = ['c1']
for epoch in range(config.epoch):
rl = [0] * 1
count = 0
epoch_loss = 0
right = 0
wrong = 0
resnet.train()
# resnet_cl.train()
for iteration, (images, labels) in enumerate(train_loader):
images, labels = images.cuda(), labels.cuda()
batch, _, height, width = images.size()
current_it = epoch * len(train_loader) + iteration
current_lr = config.lr * pow(
1 - (current_it / (len(train_loader) * config.epoch)), 0.9)
for param_group in opt.param_groups:
param_group['lr'] = current_lr
opt.zero_grad()
# print(labels)
# print(labels.size())
outputs_er, features_er = resnet(images)
# print(outputs_er.size())
loss = 1 * crit_bce(outputs_er, labels)
loss.backward()
opt.step()
gt = labels[0].cpu().detach().numpy()
num_cls = len(np.nonzero(gt)[0])
gt_cls = np.nonzero(gt)[0]
pred = outputs_er[0].cpu().detach().numpy()
pred_cls = pred.argsort()[-num_cls:][::-1]
for c in gt_cls:
if c in pred_cls:
right += 1
else:
wrong += 1
# print(right)
# print(wrong)
# opt_d.step()
rl[0] += loss.item()
count += 1
epoch_loss += loss.item() #+ loss_rec.item()
torch.cuda.empty_cache()
if iteration % config.log_step == 0:
loss_str = ''
for j in range(len(rl)):
loss_str += 'loss_' + loss_names[j]
loss_str += ' : ' + "%.4f" % (rl[j] / count)
if j != len(rl) - 1:
loss_str += ', '
print("Epoch [%d/%d],Iteration[%s] %s" %
(epoch + 1, config.epoch, current_it, loss_str))
# torch.save(netG.state_dict(),
# os.path.join(config.model_path, 'model_netG_v%d.pth' % config.version))
torch.save(
resnet.state_dict(),
os.path.join(config.model_path,
'model_resnet_er_v%d.pth' % config.version))
# torch.save(resnet_cl.state_dict(),
# os.path.join(config.model_path, 'model_resnet_cl_v%d.pth' % config.version))
acc = 100 * (right / (right + wrong))
print('Train Accuracy : ' + str(round(acc, 4)))
avg_epoch_loss = epoch_loss / len(train_loader)
print('Epoch [%d/%d], Loss_c: %.4f,' %
(epoch + 1, config.epoch, avg_epoch_loss))
####Evaluation####
val_right = 0
val_wrong = 0
resnet.eval()
for val_image, val_label, val_image_name in test_loader:
with torch.no_grad():
B, _, _, _ = val_image.size()
output, _ = resnet(val_image.cuda())
for i in range(B):
gt_cls = []
gt = val_label[i].cpu().detach().numpy()
num_cls = len(np.nonzero(gt))
for j in range(num_cls):
gt_cls.append(np.nonzero(gt)[j])
pred = output[i].cpu().detach().numpy()
pred_cls = pred.argsort()[-num_cls:][::-1]
# pdb.set_trace()
for c in gt_cls:
if c in pred_cls:
val_right += 1
else:
val_wrong += 1
# print(val_right)
# print(val_wrong)
val_acc = 100 * (val_right / (val_right + val_wrong))
print("Validation Accuracy:", val_acc)
if val_acc > best_acc:
best_acc = val_acc
# torch.save(netG.state_dict(),
# os.path.join(config.model_path, 'model_best_netG_v%d.pth' % config.version))
torch.save(
resnet.state_dict(),
os.path.join(config.model_path,
'model_best_resnet_v%d.pth' % config.version))
# torch.save(netD.state_dict(),
# os.path.join(config.model_path, 'model_best_netD_v%d.pth' % config.version))
print("save best model!")
def main_worker(gpu, ngpus_per_node, args):
global best_acc1, best_loc1, best_epoch, \
loc1_at_best_acc1, acc1_at_best_loc1, \
gtknown_at_best_acc1, gtknown_at_best_loc1
global writer
args.gpu = gpu
log_folder = os.path.join('train_log', args.name, ts)
args.save_dir = log_folder
if args.gpu == 0:
writer = SummaryWriter(logdir=log_folder)
if not os.path.isdir(log_folder):
os.makedirs(log_folder, exist_ok=True)
with open('{}/args.json'.format(log_folder), 'w') as fp:
json.dump(args.__dict__, fp)
Logger(os.path.join(log_folder, 'log.log'))
print('args: ', args)
if args.gpu is not None:
print("Use GPU: {} for training".format(args.gpu))
if args.distributed:
if args.dist_url == "env://" and args.rank == -1:
args.rank = int(os.environ["RANK"])
if args.multiprocessing_distributed:
# For multiprocessing distributed training, rank needs to be the
# global rank among all the processes
args.rank = args.rank * ngpus_per_node + gpu
dist.init_process_group(backend=args.dist_backend,
init_method=args.dist_url,
world_size=args.world_size,
rank=args.rank)
if args.dataset == 'CUB':
num_classes = 200
elif args.dataset == 'tiny_imagenet':
num_classes = 200
elif args.dataset == 'ILSVRC':
num_classes = 1000
else:
raise Exception("Not preferred dataset.")
if args.arch == 'vgg16':
model = vgg.vgg16(pretrained=True, num_classes=num_classes)
elif args.arch == 'vgg16_GAP':
model = vgg.vgg16_GAP(pretrained=True, num_classes=num_classes)
elif args.arch == 'vgg16_ADL':
model = vgg.vgg16_ADL(pretrained=True,
num_classes=num_classes,
ADL_position=args.ADL_position,
drop_rate=args.ADL_rate,
drop_thr=args.ADL_thr)
elif args.arch == 'resnet50_ADL':
model = resnet.resnet50(pretrained=True,
num_classes=num_classes,
ADL_position=args.ADL_position,
drop_rate=args.ADL_rate,
drop_thr=args.ADL_thr)
elif args.arch == 'resnet50':
model = resnet.resnet50(pretrained=True, num_classes=num_classes)
elif args.arch == 'resnet34_ADL':
model = resnet.resnet34(pretrained=True,
num_classes=num_classes,
ADL_position=args.ADL_position,
drop_rate=args.ADL_rate,
drop_thr=args.ADL_thr)
elif args.arch == 'se_resnet50_ADL':
model = resnet.resnet50_se(pretrained=True,
num_classes=num_classes,
ADL_position=args.ADL_position,
drop_rate=args.ADL_rate,
drop_thr=args.ADL_thr)
else:
model = None
if args.distributed:
# For multiprocessing distributed, DistributedDataParallel constructor
# should always set the single device scope, otherwise,
# DistributedDataParallel will use all available devices.
if args.gpu is not None:
torch.cuda.set_device(args.gpu)
model.cuda(args.gpu)
# When using a single GPU per process and per
# DistributedDataParallel, we need to divide the batch size
# ourselves based on the total number of GPUs we have
args.batch_size = int(args.batch_size / ngpus_per_node)
args.workers = int(args.workers / ngpus_per_node)
model = torch.nn.parallel.DistributedDataParallel(
model, device_ids=[args.gpu], find_unused_parameters=True)
else:
model.cuda()
# DistributedDataParallel will divide and allocate batch_size to all
# available GPUs if device_ids are not set
model = torch.nn.parallel.DistributedDataParallel(model)
elif args.gpu is not None:
torch.cuda.set_device(args.gpu)
model = model.cuda(args.gpu)
else:
# DataParallel will divide and allocate batch_size to all available GPUs
if args.arch.startswith('alexnet') or args.arch.startswith('vgg'):
model.features = torch.nn.DataParallel(model.features)
model.cuda()
else:
model = torch.nn.DataParallel(model).cuda()
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda(args.gpu)
param_features = []
param_classifiers = []
if args.arch.startswith('vgg'):
for name, parameter in model.named_parameters():
if 'features.' in name:
param_features.append(parameter)
else:
param_classifiers.append(parameter)
elif args.arch.startswith('resnet') or args.arch.startswith('se'):
for name, parameter in model.named_parameters():
if 'layer4.' in name or 'fc.' in name:
param_classifiers.append(parameter)
else:
param_features.append(parameter)
else:
raise Exception("Fail to recognize the architecture")
optimizer = torch.optim.SGD([{
'params': param_features,
'lr': args.lr
}, {
'params': param_classifiers,
'lr': args.lr * args.lr_ratio
}],
momentum=args.momentum,
weight_decay=args.weight_decay,
nesterov=args.nest)
# optionally resume from a checkpoint
if args.resume:
model, optimizer = load_model(model, optimizer, args)
# for param_group in optimizer.param_groups:
# param_group['lr'] = args.lr
cudnn.benchmark = True
# CUB-200-2011
train_loader, val_loader, train_sampler = data_loader(args)
if args.cam_curve:
cam_curve(val_loader, model, criterion, writer, args)
return
if args.evaluate:
evaluate(val_loader, model, criterion, args)
return
if args.gpu == 0:
print("Batch Size per Tower: %d" % (args.batch_size))
print(model)
for epoch in range(args.start_epoch, args.epochs):
if args.gpu == 0:
print(
"===========================================================")
print("Start Epoch %d ..." % (epoch + 1))
if args.distributed:
train_sampler.set_epoch(epoch)
adjust_learning_rate(optimizer, epoch, args)
val_acc1 = 0
val_loss = 0
val_gtloc = 0
val_loc = 0
# train for one epoch
train_acc, train_loss, progress_train = \
train(train_loader, model, criterion, optimizer, epoch, args)
if args.gpu == 0:
progress_train.display(epoch + 1)
# evaluate on validation set
if args.task == 'cls':
val_acc1, val_loss = validate(val_loader, model, criterion, epoch,
args)
# evaluate localization on validation set
elif args.task == 'wsol':
val_acc1, val_acc5, val_loss, \
val_gtloc, val_loc = evaluate_loc(val_loader, model, criterion, epoch, args)
# tensorboard
if args.gpu == 0:
writer.add_scalar(args.name + '/train_acc', train_acc, epoch)
writer.add_scalar(args.name + '/train_loss', train_loss, epoch)
writer.add_scalar(args.name + '/val_cls_acc', val_acc1, epoch)
writer.add_scalar(args.name + '/val_loss', val_loss, epoch)
writer.add_scalar(args.name + '/val_gt_loc', val_gtloc, epoch)
writer.add_scalar(args.name + '/val_loc1', val_loc, epoch)
# remember best acc@1 and save checkpoint
is_best = val_acc1 > best_acc1
best_acc1 = max(val_acc1, best_acc1)
if is_best:
best_epoch = epoch + 1
loc1_at_best_acc1 = val_loc
gtknown_at_best_acc1 = val_gtloc
if args.task == 'wsol':
# in case best loc,, Not using this.
is_best_loc = val_loc > best_loc1
best_loc1 = max(val_loc, best_loc1)
if is_best_loc:
best_epoch = epoch + 1
acc1_at_best_loc1 = val_acc1
gtknown_at_best_loc1 = val_gtloc
if args.gpu == 0:
print("\nCurrent Best Epoch: %d" % (best_epoch))
print("Top-1 GT-Known Localization Acc: %.3f \
\nTop-1 Localization Acc: %.3f\
\nTop-1 Classification Acc: %.3f" % \
(gtknown_at_best_acc1, loc1_at_best_acc1, best_acc1))
print("\nEpoch %d finished." % (epoch + 1))
if not args.multiprocessing_distributed or (
args.multiprocessing_distributed
and args.rank % ngpus_per_node == 0):
saving_dir = os.path.join(log_folder)
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_acc1': best_acc1,
'optimizer': optimizer.state_dict(),
}, is_best, saving_dir)
if args.gpu == 0:
save_train(best_acc1, loc1_at_best_acc1, gtknown_at_best_acc1,
best_loc1, acc1_at_best_loc1, gtknown_at_best_loc1, args)
print("===========================================================")
print("Start Evaluation on Best Checkpoint ...")
args.resume = os.path.join(log_folder, 'model_best.pth.tar')
model, _ = load_model(model, optimizer, args)
evaluate(val_loader, model, criterion, args)
cam_curve(val_loader, model, criterion, writer, args)
def main():
args = get_args()
if args.seed is not None:
random.seed(args.seed)
torch.manual_seed(args.seed)
cudnn.deterministic = True
warnings.warn('You have chosen to seed training. '
'This will turn on the CUDNN deterministic setting, '
'which can slow down your training considerably! '
'You may see unexpected behavior when restarting '
'from checkpoints.')
global best_acc1, best_loc1, best_epoch, \
loc1_at_best_acc1, acc1_at_best_loc1, \
gtknown_at_best_acc1, gtknown_at_best_loc1
global writer
args.gpu = 0
num_classes = 200
log_folder = os.path.join('train_log', args.name)
if args.gpu == 0:
writer = SummaryWriter(logdir=log_folder)
if not os.path.isdir(log_folder):
os.makedirs(log_folder)
Logger(os.path.join(log_folder, 'log.log'))
print(args.gpu)
model = resnet.resnet50(pretrained=True,
beta_value=50.,
num_classes=num_classes)
model = torch.nn.DataParallel(model,
device_ids=range(
torch.cuda.device_count())).cuda()
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda(args.gpu)
param_features = []
param_classifiers = []
for name, parameter in model.named_parameters():
if 'layer4.' in name or 'fc.' in name:
param_classifiers.append(parameter)
else:
param_features.append(parameter)
optimizer = torch.optim.SGD([{
'params': param_features,
'lr': args.lr
}, {
'params': param_classifiers,
'lr': args.lr * args.lr_ratio
}],
momentum=args.momentum,
weight_decay=args.weight_decay,
nesterov=args.nest)
# optionally resume from a checkpoint
if args.resume:
print(args.resume)
args.resume = os.path.join(log_folder, args.resume)
model, optimizer = load_model(model, optimizer, args)
cudnn.benchmark = True
# CUB-200-2011
train_loader, val_loader, train_sampler = data_loader(args)
mean = torch.tensor([.485, .456, .406])
std = torch.tensor([.229, .224, .225])
def normalize(x):
new_std = std[..., None, None]
new_mean = mean[..., None, None]
return (x - new_mean.cuda()) / new_std.cuda()
conv2d = nn.Conv2d(1,
1,
kernel_size=(3, 3),
bias=False,
stride=(1, 1),
padding=1)
conv2d.weight = torch.nn.Parameter((1. / 9.) * torch.ones(
(1, 1, 3, 3)).cuda())
if args.cam_curve:
print("running WSOL using cam")
cam_curve(val_loader, model, normalize, criterion, writer, args)
return
if args.grad_curve:
print("running WSOL using grad")
grad_curve(val_loader, model, normalize, criterion, writer, args)
return
if args.evaluate:
print("running evaluate")
evaluate(val_loader, model, normalize, criterion, args, conv2d)
return
if args.gpu == 0:
print("Batch Size: %d" % (args.batch_size))
print(model)
print("adv training started")
config = {'epsilon': 2. / 255., 'num_steps': 7, 'step_size': 0.5 / 255.}
print(config)
attack = AttackPGD(config, normalize)
for epoch in range(args.start_epoch, args.epochs):
if args.gpu == 0:
print(
"===========================================================")
print("Start Epoch %d ..." % (epoch + 1))
adjust_learning_rate(optimizer, epoch, args)
val_acc1 = 0
val_loss = 0
val_gtloc_g = 0
val_loc_g = 0
# train for one epoch
torch.cuda.empty_cache()
train_acc, train_loss, progress_train = \
train(train_loader, model, criterion, optimizer, epoch, args , attack , num_classes)
if args.gpu == 0:
progress_train.display(epoch + 1)
# evaluate on validation set
if args.task == 'cls':
val_acc1, val_loss = validate(val_loader, model, criterion, epoch,
args)
# evaluate localization on validation set
elif args.task == 'wsol':
val_acc1, val_acc5, val_loss, \
val_gtloc_g, val_loc_g = evaluate_loc_grad(val_loader, model, normalize, criterion, epoch, args,conv2d)
# tensorboard
if args.gpu == 0:
writer.add_scalar(args.name + '/train_acc', train_acc, epoch)
writer.add_scalar(args.name + '/train_loss', train_loss, epoch)
writer.add_scalar(args.name + '/val_cls_acc', val_acc1, epoch)
writer.add_scalar(args.name + '/val_loss', val_loss, epoch)
writer.add_scalar(args.name + '/val_gt_loc', val_gtloc_g, epoch)
writer.add_scalar(args.name + '/val_loc1', val_loc_g, epoch)
# remember best acc@1 and save checkpoint
is_best = val_acc1 > best_acc1
best_acc1 = max(val_acc1, best_acc1)
if is_best:
best_epoch = epoch + 1
loc1_at_best_acc1 = val_loc_g
gtknown_at_best_acc1 = val_gtloc_g
if args.task == 'wsol':
# in case best loc,, Not using this.
is_best_loc = val_loc_g > best_loc1
best_loc1 = max(val_loc_g, best_loc1)
if is_best_loc:
acc1_at_best_loc1 = val_acc1
gtknown_at_best_loc1 = val_gtloc_g
if args.gpu == 0:
print("\nCurrent Best Epoch: %d" % (best_epoch))
print("Top-1 GT-Known Localization Acc: %.3f \
\nTop-1 Localization Acc: %.3f\
\nTop-1 Classification Acc: %.3f" % \
(gtknown_at_best_acc1, loc1_at_best_acc1, best_acc1))
print("\nEpoch %d finished." % (epoch + 1))
saving_dir = os.path.join(log_folder)
save_dir = {
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_acc1': best_acc1,
'optimizer': optimizer.state_dict(),
}
save_checkpoint(save_dir, is_best, saving_dir)
save_checkpoint(save_dir,
is_best_loc,
saving_dir,
filename='best_loc_checkpoint.pth.tar')
save_freq = 10
if ((epoch % save_freq == 0) or (epoch == args.epochs - 1)):
save_checkpoint(save_dir,
False,
saving_dir,
filename='checkpoint_' + str(epoch) + '.pth.tar')
if args.gpu == 0:
save_train(best_acc1, loc1_at_best_acc1, gtknown_at_best_acc1,
best_loc1, acc1_at_best_loc1, gtknown_at_best_loc1, args)
print("===========================================================")
print("Start Evaluation on Best Checkpoint ...")
args.resume = os.path.join(log_folder, 'model_best.pth.tar')
model, _ = load_model(model, optimizer, args)
evaluate(val_loader, model, normalize, criterion, args, conv2d)
cam_curve(val_loader, model, normalize, criterion, writer, args)
def train(config):
if not os.path.exists(config.model_path):
os.mkdir(config.model_path)
mean_img = [0.485, 0.456, 0.406]
std_img = [0.229, 0.224, 0.225]
# transforms.Resize((384, 300)),
transformations = transforms.Compose([
transforms.RandomResizedCrop(384, scale=(0.5, 2)),
# transforms.RandomCrop(384),
# transforms.ColorJitter(brightness=0.3, contrast=0.3, saturation=0.3, hue=0.1),
transforms.RandomHorizontalFlip(p=0.25),
# transforms.RandomRotation(25),
transforms.ToTensor(),
transforms.Normalize(mean=mean_img, std=std_img),
])
inv_normalize = transforms.Normalize(
mean=[
-mean_img[0] / std_img[0], -mean_img[1] / std_img[1],
-mean_img[2] / std_img[2]
],
std=[1 / std_img[0], 1 / std_img[1], 1 / std_img[2]])
test_dataset = AI_Dataset(mode='val_refine', transform=transformations)
test_loader = torch.utils.data.DataLoader(
dataset=test_dataset,
batch_size=1, # config.batch_size
num_workers=4, #
shuffle=True,
)
device = "cuda"
pretrained = False
resnet = resnet50(pretrained=True).cuda()
state_dict = torch.load(
"C:\\Users\\sunghoon Yoon\\PycharmProjects\\AI28\\model\\model_best_resnet_v3.pth"
)
resnet.load_state_dict(state_dict)
####Evaluation####
normal = 0
abnormal = 0
TP = 0
FP = 0
FN = 0
resnet.eval()
for val_image, val_label, val_image_name in test_loader:
with torch.no_grad():
B, _, _, _ = val_image.size()
output, _ = resnet(val_image.cuda())
pdb.set_trace()
for i in range(B):
gt_cls = []
gt = val_label[i].cpu().detach().numpy()
num_cls = len(np.nonzero(gt))
for j in range(num_cls):
gt_cls.append(np.nonzero(gt)[j])
pred = output[i].cpu().detach().numpy()
pred_cls = pred.argsort()[-num_cls:][::-1]
# for c in gt_cls:
# if c in pred_cls:
# val_right += 1
# else:
# val_wrong += 1
for c in gt_cls:
if c in pred_cls:
TP += 1
if c == 1 and (pred_cls == 0):
FN += 1
if c == 0 and (pred_cls == 1):
FP += 1
for gt in gt_cls:
if gt == 0:
abnormal += 1
else:
normal += 1
# print(val_wrong)
# print(val_right)
print("normal set:", normal)
print("abnormal set:", abnormal)
val_acc = 100 * (TP / (TP + FP + FN))
print("Validation Accuracy:", val_acc)
print("TP:", TP)
print("FN:", FN)
print("FP:", FP)
print("Precision:", TP / (TP + FP))
print("Recall:", TP / (TP + FN))
tensor = (tensor - mean) / std
return tensor
if __name__ == "__main__":
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# net= vgg.vgg16_bn(pretrained=True).to(device)
net1 = resnet_cifar.resnet56().to(device)
i = 0
for mod in net1.modules():
if isinstance(mod, torch.nn.Conv2d):
i += 1
net2 = resnet.resnet50().to(device)
net3 = vgg.vgg16_bn().to(device)
test = gcn(in_features=10, out_features=10).to(device)
test.forward(net=net1,
net_name='resnet56',
dataset_name='cifar10',
rounds=2)
c = test.forward(net=net2,
rounds=2,
net_name='resnet50',
dataset_name='imagenet')
print()
# for name, module in network.named_modules():
inv_normalize = transforms.Normalize(
mean=[
-mean_img[0] / std_img[0], -mean_img[1] / std_img[1],
-mean_img[2] / std_img[2]
],
std=[1 / std_img[0], 1 / std_img[1], 1 / std_img[2]])
data_dir = "F:\\AI28_20201130\\sequence\\frost\\0"
save_dir = "F:\\AI28_20201130\\output"
type_dir = os.path.basename(os.path.dirname(data_dir))
images = glob.glob(os.path.join(data_dir, "*.png"))
resnet = resnet50(pretrained=True).cuda()
if not os.path.isdir(os.path.join(save_dir, type_dir)):
os.mkdir(os.path.join(save_dir, type_dir))
# state_dict = torch.load("C:\\Users\\sunghoon Yoon\\PycharmProjects\\AI28\\model\\model_best_resnet_v3.pth")
state_dict = torch.load(
"C:\\Users\\sunghoon Yoon\\PycharmProjects\\AI28\\model\\model_resnet_er_v3.pth"
)
resnet.load_state_dict(state_dict)
resnet.eval()
for i in range(len(images)):
image = Image.open(os.path.join(data_dir,
"%d" % i + "_0.png")).convert("RGB")
from filter_characteristic import filter_feature_extractor, predict_dead_filter
import numpy as np
# os.environ["CUDA_VISIBLE_DEVICES"] = "0,4,6,7"
# a=torch.tensor([0.9,2],dtype=torch.float,requires_grad=True)
# b=a*a
# e=a*a
# print(b)
# print(e)
# e=torch.clamp(e,min=1.5,max=5)
# c=torch.sum(e)
#
# c.backward()
# print()
a = resnet.resnet50(pretrained=False)
print()
# checkpoint=torch.load('/home/victorfang/PycharmProjects/model_pytorch/data/baseline/resnet56_cifar100_0.71580.tar')
#
# print()
#
# c=torch.load('/home/disk_new/model_saved/vgg16_bn_weighted_channel/checkpoint/flop=18923530,accuracy=0.93600.tar')
#
# network=c['network']
# network.load_state_dict(c['state_dict'])
# for mod in network.features:
# if isinstance(mod,nn.Conv2d):
# print()
# net=storage.restore_net(checkpoint=torch.load(os.path.join(conf.root_path,'baseline/resnet56_cifar10,accuracy=0.94230.tar')))
-mean_img[2] / std_img[2]
],
std=[1 / std_img[0], 1 / std_img[1], 1 / std_img[2]])
dataset = AI_Dataset(mode='val', transform=transformations)
val_loader = torch.utils.data.DataLoader(
dataset=dataset,
batch_size=1, # config.batch_size
num_workers=4, #
shuffle=True,
)
device = "cuda" # torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
resnet = resnet50(pretrained=False).cuda()
resnet.load_state_dict(
torch.load(
"C:\\Users\\sunghoon Yoon\\PycharmProjects\\AI28\\model\\model_resnet_er_v3.pth"
))
# resnet = torch.nn.DataParallel(resnet50_ysh2(pretrained=False,norm_layer=SynchronizedBatchNorm2d).cuda())
# resnet.load_state_dict(torch.load("/mnt/usb0/shyoon/CAM/model/model_resnet_er_v%d_sgd.pth" % version))
# resnet.load_state_dict(torch.load("/mnt/usb0/shyoon/CAM/model/model_best_resnet_v%d.pth" % version))
resnet.eval()
# img_dir = '/mnt/usb0/shyoon/CAM/data/VOCdevkit/VOC2012/JPEGImages/2008_*.jpg'
# images = glob.glob(img_dir)
root_dir = 'C:\\Users\\sunghoon Yoon\\PycharmProjects\\AI28\\output'
save_root_dir = os.path.join(root_dir, 'segment')
