def vis_shap(dataset_name,attack_state,loader,img): import shap raw_img=img.reshape([1,img.shape[0],img.shape[1],img.shape[2]]) img2=img.reshape([1,img.shape[2],img.shape[0],img.shape[1]]) img=raw_img for data, label in loader: x_train=data gpu_model = torch.load(dataset_name + str(attack_state) + 'prenet.ckpt') if dataset_name=='C10': model = resnet.resnet18(indim=3) elif dataset_name=='MNIST': model = resnet.resnet18(indim=1) model.load_state_dict(gpu_model.state_dict()) model.eval() x_train=x_train.numpy() background = x_train[np.random.choice(x_train.shape[0], 100, replace=False)] background=torch.Tensor(background) img2 = torch.Tensor(img2) e = shap.DeepExplainer(model, background) # ...or pass tensors directly # e = shap.DeepExplainer((model.layers[0].input, model.layers[-1].output), background) shap_values = e.shap_values(img2) shap_results=[] for kk in shap_values: shap_results.append(kk.reshape([kk.shape[0],kk.shape[2],kk.shape[3],kk.shape[1]])) # plot the feature attributions shap.image_plot(shap_results, raw_img) plt.savefig(ROOT + dataset_name + 'shap' + str(attack_state) + '.jpg') plt.close()
def vis_lrp(dataset_name,attack_state,img,label): from attribution_methods.innvestigator import InnvestigateModel img=preprocess_transform(img) img=img.view(1,img.size(0),img.size(1),img.size(2)) print(img.size()) gpu_model = torch.load(dataset_name + str(attack_state) + 'prenet.ckpt') #print(model) if dataset_name=='C10': model = resnet.resnet18(indim=3) elif dataset_name=='MNIST': model = resnet.resnet18(indim=1) model.load_state_dict(gpu_model.state_dict()) model.eval() model = torch.nn.Sequential(model, torch.nn.Softmax(dim=1)) inn_model = InnvestigateModel(model, lrp_exponent=1, method="b-rule", beta=0, epsilon=1e-6).cuda() def run_LRP(net, image_tensor): return inn_model.innvestigate(in_tensor=image_tensor, rel_for_class=1) AD_score, LRP_map = run_LRP(inn_model, img) #AD_score = AD_score[0][1].detach().cpu().numpy() LRP_map = LRP_map.detach().numpy().squeeze() mask = LRP_map print(mask.shape) raw_img = img.numpy() show_cam(raw_img, mask, 'lrp' + str(attack_state) + '.jpg')
def __init__(self): super().__init__() self.encoder = resnet18(pretrained=True) # self.encoder = resnet34(pretrained=True) self.decoder_embed = decoder_fcn.Decoder_LaneNet_TConv_Embed() self.decoder_logit = decoder_fcn.Decoder_LaneNet_TConv_Logit()
def __init__(self, embedding_size, num_classes, backbone='resnet18', mode='t'): super(background_resnet, self).__init__() self.trainMode = mode self.backbone = backbone # copying modules from pretrained models if backbone == 'resnet50': self.pretrained = resnet.resnet50(pretrained=False) elif backbone == 'resnet101': self.pretrained = resnet.resnet101(pretrained=False) elif backbone == 'resnet152': self.pretrained = resnet.resnet152(pretrained=False) elif backbone == 'resnet18': self.pretrained = resnet.resnet18(pretrained=False) elif backbone == 'resnet34': self.pretrained = resnet.resnet34(pretrained=False) else: raise RuntimeError('unknown backbone: {}'.format(backbone)) self.fc0 = nn.Linear(128, embedding_size[0]) # task specific layers for task 1 self.fc1 = nn.Linear(128, embedding_size[1]) self.bn1 = nn.BatchNorm1d(embedding_size[1]) self.relu1 = nn.ReLU() self.last1 = nn.Linear(embedding_size[1], num_classes) # task speicific layers for task 2 self.fc2 = nn.Linear(128, embedding_size[2]) self.bn2 = nn.BatchNorm1d(embedding_size[2]) self.relu2 = nn.ReLU() self.last2 = nn.Linear(embedding_size[2], num_classes)
def __init__(self, layers=18, classes=2, with_sp=True): super(BiseNet, self).__init__() self.with_sp = with_sp if layers == 18: resnet = models.resnet18(pretrained=True, deep_base=False, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1)) elif layers == 34: resnet = models.resnet34(pretrained=True, deep_base=False, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1)) if self.with_sp: self.sp = SpatialPath(in_channels=3, out_channels=128) self.cp = ContextPath(in_channels=3, out_channels=128, backbone=resnet) self.ffm = FeatureFusionModule(in_channels=256, out_channels=256) # concat: 128+128 self.conv_out = BiseNetHead(in_channels=256, mid_channels=256, classes=classes) if self.training: self.conv_out16 = BiseNetHead(in_channels=128, mid_channels=64, classes=classes) self.conv_out32 = BiseNetHead(in_channels=128, mid_channels=64, classes=classes)
def __init__(self, layers, in_channels=192, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1), pretrained=False, deep_base=False) -> None: super(ResNetDCT_345, self).__init__() if layers == 18: resnet = resnet18(pretrained, deep_base, strides=strides, dilations=dilations) elif layers == 34: resnet = resnet34(pretrained, deep_base, strides=strides, dilations=dilations) elif layers == 50: resnet = resnet50(pretrained, deep_base, strides=strides, dilations=dilations) elif layers == 101: resnet = resnet101(pretrained, deep_base, strides=strides, dilations=dilations) self.layer2, self.layer3, self.layer4, self.avgpool, self.fc = \ resnet.layer2, resnet.layer3, resnet.layer4, resnet.avgpool, resnet.fc self.relu = nn.ReLU(inplace=True) out_ch = self.layer2[0].conv1.out_channels ks = self.layer2[0].conv1.kernel_size stride = self.layer2[0].conv1.stride padding = self.layer2[0].conv1.padding self.layer2[0].conv1 = nn.Conv2d(in_channels, out_ch, kernel_size=ks, stride=stride, padding=padding, bias=False) init_weight(self.layer2[0].conv1) out_ch = self.layer2[0].downsample[0].out_channels self.layer2[0].downsample[0] = nn.Conv2d(in_channels, out_ch, kernel_size=1, stride=2, bias=False) init_weight(self.layer2[0].downsample[0])
def load_model(wts_name, n_classes): weights_path = './weights/' + wts_name model = resnet.resnet18(pretrained=False) num_ftrs = model.fc.in_features model.fc = nn.Linear(num_ftrs, n_classes) model.load_state_dict(torch.load(weights_path)) return model
def genarate_model(opt): if opt.model == 'inceptionv4': model = Inceptionv4(classes=opt.fb_cls) elif opt.model == 'resnet18': model = resnet18(num_classes=opt.fb_cls) return model
def __init__(self, model, modality='rgb', inp=3, num_classes=150, input_size=224, input_segments=8, dropout=0.5): super(tsn_model, self).__init__() if modality == 'flow': inp = 10 self.num_classes = num_classes self.inp = inp self.input_segments = input_segments self._enable_pbn = False if model == 'resnet18': self.model = resnet.resnet18(inp=inp, pretrained=True) elif model == 'resnet34': self.model = resnet.resnet34(inp=inp, pretrained=True) elif model == 'resnet50': self.model = resnet.resnet50(inp=inp, pretrained=True) elif model == 'resnet101': self.model = resnet.resnet101(inp=inp, pretrained=True) elif model == 'bn_inception': self.model = bn_inception.bninception(inp=inp) self.modality = modality self.avgpool = nn.AdaptiveAvgPool2d((1, 1)) self.dropout = nn.Dropout(p=dropout) in_channels = self.model.fc.in_features self.model.fc = None self.fc = nn.Linear(in_channels, num_classes) self.consensus = basic_ops.ConsensusModule('avg')
def __init__(self, layers=18, bins=(1, 2, 3, 6), dropout=0.1, classes=2, zoom_factor=8, use_ppm=True, criterion=nn.CrossEntropyLoss(ignore_index=255), BatchNorm=nn.BatchNorm2d, flow=False, sd=False, pretrained=True): super(PSPNet, self).__init__() assert layers in [18, 50, 101, 152] assert 512 % len(bins) == 0 assert classes > 1 assert zoom_factor in [1, 2, 4, 8] self.zoom_factor = zoom_factor self.use_ppm = use_ppm self.flow = flow self.sd = sd self.criterion = criterion models.BatchNorm = BatchNorm if layers == 50: resnet = models.resnet50(pretrained=pretrained) elif layers == 18: resnet = models.resnet18(deep_base=False, pretrained=pretrained) elif layers == 101: resnet = models.resnet101(pretrained=pretrained) else: resnet = models.resnet152(pretrained=pretrained) self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool) self.layer1, self.layer2, self.layer3, self.layer4 = resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4 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 'conv1' in n: m.stride = (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 'conv1' in n: m.stride = (1, 1) elif 'downsample.0' in n: m.stride = (1, 1) fea_dim = 512 if use_ppm: self.ppm = PPM(fea_dim, int(fea_dim / len(bins)), bins, BatchNorm) fea_dim *= 2 self.cls = nn.Sequential( nn.Conv2d(fea_dim, 256, kernel_size=3, padding=1, bias=False), BatchNorm(256), nn.ReLU(inplace=True), nn.Dropout2d(p=dropout), nn.Conv2d(256, classes, kernel_size=1) ) if self.training: self.aux = nn.Sequential( nn.Conv2d(256, 256, kernel_size=3, padding=1, bias=False), BatchNorm(256), nn.ReLU(inplace=True), nn.Dropout2d(p=dropout), nn.Conv2d(256, classes, kernel_size=1) )
def __init__(self, layers=18, dropout=0.1, classes=2): super(FFTNet23, self).__init__() if layers == 18: resnet = models.resnet18(pretrained=True, deep_base=False, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1)) elif layers == 34: resnet = models.resnet34(pretrained=True, deep_base=False, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1)) elif layers == 50: resnet = models.resnet50_semseg(pretrained=True, deep_base=True, strides=(1, 2, 1, 1), dilations=(1, 1, 2, 4)) if layers == 18 or layers == 34: self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool) else: self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.conv2, resnet.bn2, resnet.relu, resnet.conv3, resnet.bn3, resnet.relu, resnet.maxpool) self.layer1, self.layer2, self.layer3, self.layer4 = resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4 if layers == 18 or layers == 34: fea_dim = 512 aux_dim = 256 else: fea_dim = 2048 aux_dim = 1024 self.freq = nn.ModuleList() for i in range(6, 10): # the number of in_channels is 2^i self.freq.append( FeatureFrequencySeparationModule( in_channels=2**i, up_channels=2**i if i == 6 else 2**(i - 1), smf_channels=128, high_ratio=1 - 0.2 * (i - 5), # high_ratio=0.5, low_ratio=0.2, up_flag=False if i == 6 else True, smf_flag=True if i % 2 == 0 else False, )) self.fa_cls_seg = nn.Sequential(nn.Dropout2d(p=dropout), nn.Conv2d(256, classes, kernel_size=1)) if self.training: self.aux = nn.Sequential( nn.Conv2d(aux_dim, aux_dim // 4, kernel_size=3, padding=1, bias=False), nn.BatchNorm2d(aux_dim // 4), nn.ReLU(inplace=True), nn.Dropout2d(p=dropout), nn.Conv2d(aux_dim // 4, classes, kernel_size=1))
def __init__(self): super().__init__() # comment or uncomment to choose from different encoders and decoders self.encoder = resnet18(pretrained=True) # self.encoder = resnet34(pretrained=True) self.decoder = decoder_fcn.Decoder_LaneNet_TConv() # Decoder with Transposed Conv
def __init__(self, layers=50, dropout=0.1, classes=2, block_size=8, sub_sampling='4:2:0', quality_factor=99, threshold=0.0, vec_dim=300): super(DCTNet, self).__init__() assert layers in [18, 34, 50, 101] assert classes > 1 self.classes = classes self.block_size = block_size self.sub_sampling = sub_sampling self.quality_factor = quality_factor self.thresh = threshold # the quantisation matrices for the luminace channel (QY) self.QY=np.array([[16,11,10,16,24,40,51,61], [12,12,14,19,26,48,60,55], [14,13,16,24,40,57,69,56], [14,17,22,29,51,87,80,62], [18,22,37,56,68,109,103,77], [24,35,55,64,81,104,113,92], [49,64,78,87,103,121,120,101], [72,92,95,98,112,100,103,99]]) # the quantisation matrices for the chrominance channels (QC) self.QC=np.array([[17,18,24,47,99,99,99,99], [18,21,26,66,99,99,99,99], [24,26,56,99,99,99,99,99], [47,66,99,99,99,99,99,99], [99,99,99,99,99,99,99,99], [99,99,99,99,99,99,99,99], [99,99,99,99,99,99,99,99], [99,99,99,99,99,99,99,99]]) # Backbone # if layers in [18,34]: resnet = resnet18(pretrained=False, deep_base=False, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1)) self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool) self.layer1, self.layer2, self.layer3, self.layer4 = \ resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4 if layers == 18 or layers == 34: fea_dim = 512 else: fea_dim = 2048 down_dim = fea_dim // 4 self.cls = nn.Sequential( nn.Conv2d(fea_dim, down_dim, kernel_size=3, padding=1, bias=False), nn.BatchNorm2d(down_dim), nn.ReLU(inplace=True), nn.Dropout2d(p=dropout), nn.Conv2d(down_dim, classes, kernel_size=1) )
def __init__(self, layers=50, dropout=0.1, classes=2, use_dct=True, use_bise=True, vec_dim=300): super(DCTNet, self).__init__() assert layers in [18, 34, 50, 101] assert classes > 1 self.use_dct = use_dct self.use_bise = use_bise self.vec_dim = vec_dim if layers == 18: resnet = models.resnet18(pretrained=False, deep_base=False, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1)) elif layers == 34: resnet = models.resnet34(pretrained=True, deep_base=False, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1)) elif layers == 50: resnet = models.resnet50_semseg(pretrained=True, deep_base=True, strides=(1, 2, 1, 1), dilations=(1, 1, 2, 4)) elif layers == 101: resnet = models.resnet101_semseg(pretrained=True, deep_base=True, strides=(1, 2, 1, 1), dilations=(1, 1, 2, 4)) if layers == 18 or layers == 34: self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool) else: self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.conv2, resnet.bn2, resnet.relu, resnet.conv3, resnet.bn3, resnet.relu, resnet.maxpool) self.layer1, self.layer2, self.layer3, self.layer4 = resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4 if layers == 18 or layers == 34: fea_dim = 512 aux_dim = 256 else: fea_dim = 2048 aux_dim = 1024 down_dim = fea_dim // 4 if use_dct: self.dct_encoding = DCTModule(vec_dim=self.vec_dim) if use_bise: self.ffm = FeatureFusionModule( in_channels=self.vec_dim + 128, out_channels=fea_dim) # concat: 128+128 self.cls = nn.Sequential( nn.Conv2d(fea_dim, down_dim, kernel_size=3, padding=1, bias=False), nn.BatchNorm2d(down_dim), nn.ReLU(inplace=True), nn.Dropout2d(p=dropout), nn.Conv2d(down_dim, classes, kernel_size=1) ) if self.training: self.aux = nn.Sequential( nn.Conv2d(aux_dim, aux_dim // 4, kernel_size=3, padding=1, bias=False), nn.BatchNorm2d(aux_dim // 4), nn.ReLU(inplace=True), nn.Dropout2d(p=dropout), nn.Conv2d(aux_dim // 4, classes, kernel_size=1) )
def __init__(self, layers=50, dropout=0.1, classes=2, use_dct=True, vec_dim=300): super(DCTNet, self).__init__() assert layers in [18, 34, 50, 101] assert classes > 1 self.use_dct = use_dct self.vec_dim = vec_dim if layers == 18: resnet = models.resnet18(pretrained=False, deep_base=False, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1)) elif layers == 34: resnet = models.resnet34(pretrained=True, deep_base=False, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1)) if layers == 18 or layers == 34: self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool) else: self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.conv2, resnet.bn2, resnet.relu, resnet.conv3, resnet.bn3, resnet.relu, resnet.maxpool) self.layer1, self.layer2, self.layer3 = resnet.layer1, resnet.layer2, resnet.layer3 if layers == 18 or layers == 34: fea_dim = 256 down_dim = fea_dim // 4 if use_dct: self.dct_encoding = DCTModule(vec_dim=self.vec_dim) self.up_conv = ConvBNReLU(fea_dim, fea_dim, ks=1, stride=1, padding=0) self.cls = nn.Sequential( nn.Conv2d(fea_dim, down_dim, kernel_size=3, padding=1, bias=False), nn.BatchNorm2d(down_dim), nn.ReLU(inplace=True), nn.Dropout2d(p=dropout), nn.Conv2d(down_dim, classes, kernel_size=1))
def __init__(self, opt): super(EncoderDecoder, self).__init__() if opt.SVR: self.encoder = resnet.resnet18(pretrained=False, num_classes=opt.bottleneck_size) else: self.encoder = PointNet(nlatent=opt.bottleneck_size) self.decoder = Atlasnet(opt) self.to(opt.device) if not opt.SVR: self.apply(weights_init) # initialization of the weights self.eval()
def test(path): model = resnet.resnet18(num_classes=3919) model.load_state_dict(torch.load(args.checkpoint)) model.cuda() model.eval() # probe list_probe = os.listdir(os.path.join(path, 'probe')) p_array = np.zeros((len(list_probe), 512)) # m个待查询的probe特征 p_name = [] for i, img_p in enumerate(sorted(list_probe)): p_name.append(img_p) img = cv2.imread(os.path.join(path, 'probe', img_p)) img_tensor = transforms.ToTensor()(img).unsqueeze(0) feature, out = model(Variable(img_tensor.cuda())) p_array[i] = feature.cpu().detach().numpy() # gallery && confidence[m][n] list_gallery = os.listdir(os.path.join(path, 'gallery')) confidence_array = np.zeros((len(p_array), len(list_gallery)), dtype=np.float) for n, dir_name in enumerate(sorted(list_gallery)): # n个id对应的文件夹 dir_list = os.listdir(os.path.join(path, 'gallery', dir_name)) g_array_dir = np.empty((len(dir_list), 512)) # 每个文件夹对应生成的特征 for i, img_g in enumerate(sorted(dir_list)): img = cv2.imread(os.path.join(path, 'gallery', dir_name, img_g)) img_tensor = transforms.ToTensor()(img).unsqueeze(0) feature, out = model(Variable(img_tensor.cuda())) g_array_dir[i] = feature.cpu().detach().numpy() # confidence_array = strategy_mean(confidence_array, p_array, g_array_dir, n) confidence_array = strategy_max(confidence_array, p_array, g_array_dir, n) # 将结果写入csv文件中 with open('output/test.csv', 'w', newline='') as csvfile: writer = csv.writer(csvfile) for m in range(confidence_array.shape[0]): line = {} write_line = [p_name[m]] for n in range(confidence_array.shape[1]): line[('000' + str(n))[-4:]] = confidence_array[m][n] line_reverse = sorted(line.items(), key=lambda x: x[1], reverse=True) for t in range(len(line)): write_line.append(line_reverse[t][0]) write_line.append(line_reverse[t][1]) writer.writerow(write_line) return p_name
def main(args): checkpoint = torch.load(args.model_path) backbone = resnet18(num_classes=6).cuda() backbone.load_state_dict(checkpoint['backbone']) my_val_dataset = HandDataloader(args.test_dataset, transforms=None, train=False) my_val_dataloader = DataLoader(my_val_dataset, batch_size=2, shuffle=True, num_workers=0) validate(my_val_dataloader, backbone)
def main(): pth_path = '/home/zhaoliu/car_class+ori/results/resnet_18_newval/save_27.pth' test_result = Path('/home/zhaoliu/car_class+ori/test_result') test_path = '/home/zhaoliu/car_data/训练数据/4.9新加测试集/val_lmdb' keys_path = '/home/zhaoliu/car_data/训练数据/4.9新加测试集/new_val.npy' # test_path = '/mnt/disk/zhaoliu_data/carlogo/lmdb/carlogo_train_new/car_256_all_lmdb' # keys_path = '/home/zhaoliu/car_data/val.npy' badcase_npy = '/home/zhaoliu/car_class+ori/test_result/badcase_val_aug.npy' model = resnet18(num_classes=21) model = resume_model(pth_path, model) test_loader, test_batch_logger, test_logger = get_test_utils( test_path, test_result, keys_path) print('数据加载完毕...') test(model, test_loader, test_batch_logger, test_logger, badcase_npy)
def main(): pth_path = '/home/zhaoliu/car_brand/results/fuxian/save_15.pth' test_result = '/home/zhaoliu/car_full/badcase/' test_path = '/home/zhaoliu/car_data/训练数据/4.9新加测试集/val_lmdb' keys_path = '/home/zhaoliu/car_data/训练数据/4.9新加测试集/new_val.npy' fullnpy_path = test_result + 'full_badkeys.npy' fulltxt_path = test_result + 'full_badcase_info.txt' model = resnet18(num_classes=27249) model = resume_model(pth_path, model) test_loader = get_test_utils(test_path, keys_path) print('数据加载完毕...') test(model, test_loader, fullnpy_path, fulltxt_path)
def create_model_optimizer_scheduler(args, dataset_class, optimizer='adam', scheduler='steplr', load_optimizer_scheduler=False): if args.arch == 'wideresnet': model = WideResNet(depth=args.layers, num_classes=dataset_class.num_classes, widen_factor=args.widen_factor, dropout_rate=args.drop_rate) elif args.arch == 'densenet': model = densenet121(num_classes=dataset_class.num_classes) elif args.arch == 'lenet': model = LeNet(num_channels=3, num_classes=dataset_class.num_classes, droprate=args.drop_rate, input_size=dataset_class.input_size) elif args.arch == 'resnet': model = resnet18(num_classes=dataset_class.num_classes, input_size=dataset_class.input_size, drop_rate=args.drop_rate) else: raise NotImplementedError print('Number of model parameters: {}'.format( sum([p.data.nelement() for p in model.parameters()]))) model = model.cuda() if optimizer == 'adam': optimizer = torch.optim.Adam(model.parameters(), lr=args.lr) else: optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum, nesterov=args.nesterov, weight_decay=args.weight_decay) if scheduler == 'steplr': scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.2) else: args.iteration = args.fixmatch_k_img // args.batch_size args.total_steps = args.fixmatch_epochs * args.iteration scheduler = get_cosine_schedule_with_warmup( optimizer, args.fixmatch_warmup * args.iteration, args.total_steps) if args.resume: if load_optimizer_scheduler: model, optimizer, scheduler = resume_model(args, model, optimizer, scheduler) else: model, _, _ = resume_model(args, model) return model, optimizer, scheduler
def __init__(self, layers=50, block_size=8): super(ContextPath, self).__init__() assert layers in [18, 34, 50, 101] self.layers = layers self.block_size = block_size # Backbone # if layers in [18,34]: # resnet = ResNetDCT_345(layers, in_channels=192, pretrained=False, deep_base=False, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1)) # # resnet = ResNetDCT_345(layers, pretrained=False, deep_base=False, strides=(1, 2, 1, 1), dilations=(1, 1, 2, 4)) # self.layer2, self.layer3, self.layer4 = \ # resnet.layer2, resnet.layer3, resnet.layer4 # resnet = ResNetDCT_2345(layers, in_channels=192, pretrained=False, deep_base=False, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1)) # if layers in [18,34]: # self.down_layer = resnet.down_layer resnet = resnet18(pretrained=False, deep_base=False, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1)) self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool) self.layer1, self.layer2, self.layer3, self.layer4 = \ resnet.layer1,resnet.layer2, resnet.layer3, resnet.layer4
def __init__(self, backbone='resnet18', pretrained_base=True, norm_layer=nn.BatchNorm2d, **kwargs): super(ContextPath, self).__init__() if backbone == 'resnet18': pretrained = resnet18(pretrained=pretrained_base, **kwargs) else: raise RuntimeError('unknown backbone: {}'.format(backbone)) self.conv1 = pretrained.conv1 self.bn1 = pretrained.bn1 self.relu = pretrained.relu self.maxpool = pretrained.maxpool self.layer1 = pretrained.layer1 self.layer2 = pretrained.layer2 self.layer3 = pretrained.layer3 self.layer4 = pretrained.layer4 inter_channels = 128 self.global_context = _GlobalAvgPooling(512, inter_channels, norm_layer) self.arms = nn.ModuleList([ AttentionRefinmentModule(512, inter_channels, norm_layer, **kwargs), AttentionRefinmentModule(256, inter_channels, norm_layer, **kwargs) ]) self.refines = nn.ModuleList([ _ConvBNReLU(inter_channels, inter_channels, 3, 1, 1, norm_layer=norm_layer), _ConvBNReLU(inter_channels, inter_channels, 3, 1, 1, norm_layer=norm_layer) ])
def save_model(data_loader, dataset_sizes, n_classes, device, arg_data, version, num_epochs): # 모델 학습 model_ft = resnet.resnet18(pretrained=True) num_ftrs = model_ft.fc.in_features model_ft.fc = nn.Linear(num_ftrs, n_classes) model_ft = model_ft.to(device) criterion = nn.CrossEntropyLoss() optimizer_ft = optim.SGD(model_ft.parameters(), lr=0.001, momentum=0.9) exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1) model_ft, best_acc, fvs, label_epoch = train_model(data_loader, dataset_sizes, model_ft, criterion, optimizer_ft, exp_lr_scheduler, num_epochs, device) ################ # weight 저장 wts_save_path = './weights/' torch.save(model_ft.state_dict(), wts_save_path+'weights_{}_ver{} (epochs={}).pth'.format(arg_data, version, num_epochs)) return fvs, label_epoch
def __init__(self, layers=18, classes=2): super(TriSeNet, self).__init__() if layers == 18: backbone = models.resnet18(pretrained=True, deep_base=False, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1)) elif layers == 34: backbone = models.resnet34(pretrained=True, deep_base=False, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1)) # the initial layer conv is 7x7, instead of three 3x3 self.layer0 = nn.Sequential(backbone.conv1, backbone.bn1, backbone.relu, backbone.maxpool) # stage channels for resnet18 and resnet34 are:(64, 128, 256, 512) self.layer1, self.layer2, self.layer3, self.layer4 \ = backbone.layer1, backbone.layer2, backbone.layer3, backbone.layer4 # self.gap = nn.AdaptiveAvgPool2d(1) # Global Average Pooling # self.up_16_8 = UpModule(in_channels=256, out_channels=128, up_scale=2) # feat_16 up to the size of feat_8 # self.up_32_8 = UpModule(in_channels=512, out_channels=128, up_scale=4) # self.down_8_16 = DownModule(in_channels=128, out_channels=256, down_scale=2) # feat_8 down to the size of feat_16 # self.up_32_16 = UpModule(in_channels=512, out_channels=256, up_scale=2) self.down_8_32 = DownModule(in_channels=128, out_channels=512, down_scale=4) # self.down_16_32 = DownModule(in_channels=256, out_channels=512, down_scale=2) self.relu = nn.ReLU(inplace=True) self.sa_8_32 = SelfAttentionBlock(512) # self.ca_32_8 = ChannelAttentionModule(in_channels=128, reduction=4) # self.cp = ContextPath(in_channels=3, out_channels=128, backbone=resnet) self.seg_head = SegHead(in_channels=640, mid_channels=256, classes=classes)
def __init__(self, layers=50, dropout=0.1, classes=2, fuse=8): super(TriSeNet1, self).__init__() assert layers in [18, 34, 50, 101] assert classes > 1 self.fuse = fuse # Backbone if layers == 18: resnet = models.resnet18(pretrained=False, deep_base=False, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1)) elif layers == 34: resnet = models.resnet34(pretrained=True, deep_base=False, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1)) elif layers == 50: resnet = models.resnet50_semseg(pretrained=True, deep_base=True, strides=(1, 2, 1, 1), dilations=(1, 1, 2, 4)) elif layers == 101: resnet = models.resnet101_semseg(pretrained=True, deep_base=True, strides=(1, 2, 1, 1), dilations=(1, 1, 2, 4)) if layers == 18 or layers == 34: self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool) else: self.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.conv2, resnet.bn2, resnet.relu, resnet.conv3, resnet.bn3, resnet.relu, resnet.maxpool) self.layer1, self.layer2, self.layer3, self.layer4 = resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4 if layers == 18 or layers == 34: fea_dim = 512 aux_dim = 256 else: fea_dim = 2048 aux_dim = 1024 down_dim = fea_dim // 4 self.cls = nn.Sequential( nn.Conv2d(fea_dim, down_dim, kernel_size=3, padding=1, bias=False), nn.BatchNorm2d(down_dim), nn.ReLU(inplace=True), nn.Dropout2d(p=dropout), nn.Conv2d(down_dim, classes, kernel_size=1) ) if self.fuse == 16 or self.fuse == 8: self.fuse_16 = nn.Conv2d(fea_dim//2, classes, kernel_size=1) if self.fuse == 8: self.fuse_8 = nn.Conv2d(fea_dim//4, classes, kernel_size=1)
def __init__(self, embedding_size, num_classes, backbone='resnet50'): super(background_resnet, self).__init__() self.backbone = backbone # copying modules from pretrained models if backbone == 'resnet50': self.pretrained = resnet.resnet50(pretrained=False) elif backbone == 'resnet101': self.pretrained = resnet.resnet101(pretrained=False) elif backbone == 'resnet152': self.pretrained = resnet.resnet152(pretrained=False) elif backbone == 'resnet18': self.pretrained = resnet.resnet18(pretrained=False) elif backbone == 'resnet34': self.pretrained = resnet.resnet34(pretrained=False) else: raise RuntimeError('unknown backbone: {}'.format(backbone)) self.fc0 = nn.Linear(512, embedding_size) self.bn0 = nn.BatchNorm1d(embedding_size) self.relu = nn.ReLU() self.last = nn.Linear(embedding_size, num_classes)
def __init__(self, layers, in_channels=192, strides=(1, 2, 2, 2), dilations=(1, 1, 1, 1), pretrained=False, deep_base=False) -> None: super(ResNetDCT_2345, self).__init__() self.layers = layers if layers == 18: resnet = resnet18(pretrained, deep_base, strides=strides, dilations=dilations) elif layers == 34: resnet = resnet34(pretrained, deep_base, strides=strides, dilations=dilations) elif layers == 50: resnet = resnet50(pretrained, deep_base, strides=strides, dilations=dilations) elif layers == 101: resnet = resnet101(pretrained, deep_base, strides=strides, dilations=dilations) self.layer1, self.layer2, self.layer3, self.layer4, self.avgpool, self.fc = \ resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4, resnet.avgpool, resnet.fc self.relu = nn.ReLU(inplace=True) if layers in [18, 34]: in_ch = self.layer1[0].conv1.in_channels self.down_layer = nn.Sequential( nn.Conv2d(in_channels, in_ch, kernel_size=1, stride=1, bias=False), nn.BatchNorm2d(in_ch), nn.ReLU(inplace=True) ) # initialize the weight for only one layer for m in self.down_layer.modules(): init_weight(m) else: out_ch = self.layer1[0].conv1.out_channels self.layer1[0].conv1 = nn.Conv2d(in_channels, out_ch, kernel_size=1, stride=1, bias=False) init_weight(self.layer1[0].conv1) out_ch = self.layer1[0].downsample[0].out_channels self.layer1[0].downsample[0] = nn.Conv2d(in_channels, out_ch, kernel_size=1, stride=1, bias=False) init_weight(self.layer1[0].downsample[0])
elif args.activation == 'sigmoid': activate = nn.Sigmoid elif args.activation == 'tanh': activate = nn.Tanh else: raise ValueError( 'activation should be relu/elu/leakyrelu/rrelu/sigmoid/tanh') # 设置是否使用多一层隐藏层+dropout hidden = int(args.hidden) # 选择模型 if args.layer == '18': net = resnet18(pretrained=False, progress=True, activate=activate, hidden=hidden, num_classes=10) elif args.layer == '34': net = resnet34(pretrained=False, progress=True, activate=activate, hidden=hidden, num_classes=10) elif args.layer == '50': net = resnet50(pretrained=False, progress=True, activate=activate, hidden=hidden, num_classes=10) elif args.layer == '101':
tf_record = './runs/' if not os.path.exists(tf_record): os.mkdir(tf_record) tf_record = os.path.join(tf_record, args.arch + '_' + args.method) writer = SummaryWriter(tf_record) else: writer = None # batch size train_batchSize = [args.label_batch_size, args.unlabel_batch_size] # backbone architecture if args.arch == 'resnet18': backbone = resnet.resnet18(feature_len=args.feat_len) elif args.arch == 'resnet34': backbone = resnet.resnet34(feature_len=args.feat_len) elif args.arch == 'resnet50': backbone = resnet.resnet50(feature_len=args.feat_len) elif args.arch == 'resnet101': backbone = resnet.resnet101(feature_len=args.feat_len) elif args.arch == 'resnet152': backbone = resnet.resnet152(feature_len=args.feat_len) elif args.arch == 'usr': backbone = model_usr else: raise NameError( 'Arch %s is not support. Please enter from [resnet18, resnet34, resnet50, resnet101, resnet152, usr]' % args.arch)