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