def __init__(self, model_name='resnet34', num_classes=43): super().__init__() if model_name.lower() == 'resnet34': self.backbone = ptcv_get_model("resnet34", pretrained=True) self.backbone.features.final_pool = nn.AdaptiveAvgPool2d(1) self.backbone.output = nn.Linear(512, num_classes) # self.backbone.output = nn.Sequential(nn.Linear(512, 128), # swish(), # nn.Dropout(p=0.5), # nn.Linear(128, num_classes)) elif model_name.lower() == 'efficientnet_b7': self.backbone = EfficientNet.from_pretrained('efficientnet-b7') # self.backbone._fc = nn.Linear(2560, num_classes) self.backbone._fc = nn.Sequential(nn.Linear(2560, 256), Mish(), nn.Dropout(p=0.5), nn.Linear(256, num_classes)) elif model_name.lower() == 'se_resnext101': self.backbone = ptcv_get_model("seresnext101_32x4d", pretrained=True) self.backbone.features.final_pool = nn.AdaptiveAvgPool2d(1) self.backbone.output = nn.Sequential(nn.Linear(2048, 256), Mish(), nn.Dropout(p=0.5), nn.Linear(256, num_classes)) else: raise NotImplementedError
def __init__(self, net='seresnext50', pretrained=False, num_classes=1, dropout_flag=False, size=512): super(MySeResnext, self).__init__() self.dropout_flag = dropout_flag self.size = size if net == 'seresnext50': seresnext50 = ptcv_get_model("seresnext50_32x4d", pretrained=pretrained) if self.size == 224: self.model = nn.Sequential(*(list(seresnext50.children())[0])) else: self.model = nn.Sequential(*(list(seresnext50.children())[0][:-1])) elif net == 'seresnext101': seresnext101 = ptcv_get_model("seresnext101_32x4d", pretrained=pretrained) if self.size == 224: self.model = nn.Sequential(*(list(seresnext101.children())[0])) else: self.model = nn.Sequential(*(list(seresnext101.children())[0][:-1])) else: raise Warning("Wrong Net Name!!") if self.size != 224: self.avgpool = nn.AvgPool2d(int(size / 32), stride=1) if self.dropout_flag: self.dropout = nn.Dropout(0.5) self.last_fc = nn.Linear(2048, num_classes)
def init_network(params): # parse params with default values architecture = params.get('architecture', 'seresnet50') combination = params.get('combination', 'MG') pretrained = params.get('pretrained', True) classes = params.get('classes', 17331) output_dim = params.get('output_dim', 1536) # loading backbone network from pytorchcv # Github : https://github.com/osmr/imgclsmob/tree/master/pytorch if pretrained: net_in = ptcv_get_model(architecture, pretrained=True) else: net_in = ptcv_get_model(architecture, pretrained=False) features = list(net_in.children())[:-1] combination = COMBINATION[combination] meta = { 'architecture': architecture, 'outputdim': output_dim, 'classes': classes } net = CGD(features, combination, output_dim, classes, meta) return net
def test(model_name, dataset_name, epsilon, temperature, out_dir: str): print('Load model: {}'.format(model_name)) model = None if 'densenet' in model_name: trainset_name = 'cifar' + model_name.split('densenet')[-1] model = ptcv_get_model("densenet100_k12_bc_%s" % trainset_name, pretrained=True) elif 'resnet' in model_name: trainset_name = 'cifar' + model_name.split('resnet')[0] model = ptcv_get_model("wrn28_10_%s" % trainset_name, pretrained=True) assert isinstance(model, torch.nn.Module) model.cuda() print('Create Dataloaders: {}'.format(dataset_name)) testloader = None # if dataset_name != "Uniform" and dataset_name != "Gaussian": # tests_ood = ImageFolder(osp.join('..', 'data', dataset_name), transform=transform) # testloader = data.DataLoader(tests_ood, batch_size=1, shuffle=False, num_workers=4) if dataset_name == 'cifar10': testset = CIFAR10(root=osp.join('..', 'data'), train=False, download=True, transform=transform) testloader = data.DataLoader(testset, batch_size=1, shuffle=False, num_workers=4) elif dataset_name == 'cifar100': testset = CIFAR100(root=osp.join('..', 'data'), train=False, download=True, transform=transform) testloader = data.DataLoader(testset, batch_size=1, shuffle=False, num_workers=4) elif dataset_name in ['Uniform', 'Gaussian']: testset = CIFAR10(root=osp.join('..', 'data'), train=False, download=True, transform=transform) testloader = data.DataLoader(testset, batch_size=1, shuffle=False, num_workers=4) elif dataset_name == 'SVHN': testset = SVHN(root=osp.join('..', 'data'), split='test', download=True, transform=transform) testloader = data.DataLoader(testset, batch_size=1, shuffle=False, num_workers=4) print('Produce score: {}'.format(dataset_name)) produce_score(model, testloader, model_name, dataset_name, epsilon, temperature, out_dir)
def create_fmodel(dataset="tiny_imagenet",model_name="resnet18",gpu=None): if dataset == "imagenet": model = ptcv_get_model(model_name, pretrained=True) model.eval() if gpu is not None: model = model.cuda() # # def preprocessing(x): # mean = np.array([0.485, 0.456, 0.406]) # std = np.array([0.229, 0.224, 0.225]) # _mean = mean.astype(x.dtype) # _std = std.astype(x.dtype) # x = x - _mean # x /= _std # # assert x.ndim in [3, 4] # if x.ndim == 3: # x = np.transpose(x, axes=(2, 0, 1)) # elif x.ndim == 4: # x = np.transpose(x, axes=(0, 3, 1, 2)) # # def grad(dmdp): # assert dmdp.ndim == 3 # dmdx = np.transpose(dmdp, axes=(1, 2, 0)) # return dmdx / _std # return x, grad preprocessing = dict(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], axis=-3) fmodel = PyTorchModel(model, bounds=(0, 1), num_classes=1000, preprocessing=preprocessing) elif dataset == "cifa10": model = ptcv_get_model(model_name, pretrained=True) model.eval() if gpu is not None: model = model.cuda() preprocessing = dict(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], axis=-3) fmodel = PyTorchModel(model, bounds=(0, 1), num_classes=10, preprocessing=preprocessing) elif dataset == "dev": model = ptcv_get_model(model_name, pretrained=True) model.eval() if gpu is not None: model = model.cuda() preprocessing = dict(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], axis=-3) fmodel = PyTorchModel(model, bounds=(0, 1), num_classes=1000, preprocessing=preprocessing) return fmodel
def get_menet_456(pretrained=False): net = ptcv_get_model("menet456_24x1_g3", pretrained=False) if pretrained: net = ptcv_get_model("menet456_24x1_g3", pretrained=True) num_ftrs = net.output.in_features out_ftrs = int(net.output.out_features / 4) net.output = nn.Sequential( nn.Sigmoid(), nn.Dropout(0.5), nn.Linear(num_ftrs, out_ftrs, bias=True), nn.SELU(), nn.Dropout(0.7), nn.Linear(in_features=out_ftrs, out_features=1, bias=True), ) return net
def get_model(model_name, load_model='None', batch_size=32, device='cuda:0', pretrained=False): if model_name == 'shufflenetv2x0.5': model = ptcv_get_model('shufflenetv2_wd2', pretrained=pretrained) num_ftrs = model.output.in_features model.output = nn.Linear(num_ftrs, 2) else: raise NotImplementedError print('testing model') x = torch.randn(16, 3, 192, 192) y = model(x) print(y.size()) print('model all set') # model must be converted to device and DataParallel so that checkpoint can be loaded model.to(device) model = nn.DataParallel(model) if load_model != 'None': checkpoint = torch.load(load_model) model.load_state_dict(checkpoint) return model
def densenet(dataset: str, depth: int, pretrained=False) -> Module: """ Wrapper for densenet available in the pytorchcv package. :param dataset: One of cifar10, cifar100, svhn, imagenet. :param depth: The depth of the densnet. For imagenet depths (121, 161, 169, 201) are supported. The other datasets support dephts (40, 100). :param pretrained: load model pretrained on `dataset`.. """ if dataset in ["cifar10", "cifar100", "svhn"]: available_depths = [40, 100] # other growth rates are available through the general method. growth_rate = 12 model_name = f"densenet{depth}_k{growth_rate}_{dataset}" elif dataset == "imagenet": available_depths = [121, 161, 169, 201] model_name = f"densenet{depth}" else: raise ValueError(f"Unrecognized dataset {dataset}") if depth not in available_depths: raise ValueError(f"Depth {depth} not available for dataset {dataset}, " f"availble depths are {available_depths}") model = ptcv_get_model(model_name, pretrained=pretrained) return model
def efficientnet_b1b(in_channels, num_classes, pretrained=True): model = ptcv_get_model("efficientnet_b1b", pretrained=True) print(model) model.output = nn.Sequential( nn.Dropout(p=0.3, inplace=False), nn.Linear(1280, 7, bias=True) ) return model
def pyramidnet(dataset: str, depth: int, pretrained=False) -> Module: """ Wrapper for pyramidnet available in the pytorchcv package. :param dataset: One of cifar10, cifar100, svhn, imagenet. :param depth: The depth of the pyramidnet. For imagenet 101 is supported. The other datasets support dephts (110, 164, 200, 236, 272). :param pretrained: load model pretrained on `dataset`.. """ if dataset in ["cifar10", "cifar100", "svhn"]: available_depths = [110, 164, 200, 236, 272] alpha = {110: 48, 164: 270, 200: 240, 236: 220, 272: 200}.get(depth) if depth < 200: model_name = f"pyramidnet{depth}_a{alpha}_{dataset}" else: # These models have batch normalization model_name = f"pyramidnet{depth}_a{alpha}_bn_{dataset}" elif dataset == "imagenet": available_depths = [101] alpha = 360 model_name = f"pyramidnet{depth}_a{alpha}" else: raise ValueError(f"Unrecognized dataset {dataset}") if depth not in available_depths: raise ValueError(f"Depth {depth} not available for dataset {dataset}, " f"availble depths are {available_depths}") model = ptcv_get_model(model_name, pretrained=pretrained) return model
def __init__(self, model_name, ds_train, ds_val, ds_test, batch_size=64): super(MelanomaModel, self).__init__() self.ds_train = ds_train self.ds_val = ds_val self.ds_test = ds_test self.batch_size = batch_size self.val_logloss = dict() self.val_auc = dict() self.oof_preds = dict() if "efficient" in model_name: self.net = ptcv_get_model(model_name, pretrained=True) self.n_map_features = self.net.output.fc.in_features self.fc = nn.Linear(in_features=self.net.output.fc.in_features, out_features=1) self.net.output.fc = nn.Identity() elif "resne" in model_name: self.net = models.resnet18(pretrained=True) self.n_map_features = list(self.net.children())[-1].in_features self.fc = nn.Linear(in_features=self.net.fc.in_features, out_features=1) self.net.fc = nn.Identity() else: raise Exception("未実装")
def _set_model(self): if self.settings.dataset in ["cifar100"]: self.test_input = Variable(torch.randn(1, 3, 32, 32).cuda()) self.model = ptcv_get_model('resnet20_cifar100', pretrained=True) self.model_teacher = ptcv_get_model('resnet20_cifar100', pretrained=True) self.model_teacher.eval() elif self.settings.dataset in ["imagenet"]: self.test_input = Variable(torch.randn(1, 3, 224, 224).cuda()) self.model = ptcv_get_model('resnet18', pretrained=True) self.model_teacher = ptcv_get_model('resnet18', pretrained=True) self.model_teacher.eval() else: assert False, "unsupport data set: " + self.settings.dataset
def __init__(self, mult=1.0, feature_levels=(3, 4, 5), pretrained=True, include_final=False, **kwargs): super().__init__() _check_levels(feature_levels) self.forward_levels = tuple(range(1, feature_levels[-1] + 1)) self.feature_levels = feature_levels net = ptcv_get_model(self.mult2name[mult], pretrained=pretrained) del net.output net = net.features self.layer1 = net.init_block.conv self.layer2 = net.init_block.pool self.layer3 = net.stage1 self.layer4 = net.stage2 if include_final: self.layer5 = nn.Sequential( net.stage3, net.final_block, ) else: self.layer5 = net.stage3 out_channels = [ get_out_channels(self.layer1), get_out_channels(self.layer1), calc_out_channels(self.layer3), calc_out_channels(self.layer4), calc_out_channels(self.layer5), ] self.out_channels = [out_channels[i - 1] for i in feature_levels]
def __init__(self, name, feature_levels=(3, 4, 5), pretrained=True): super().__init__() _check_levels(feature_levels) self.forward_levels = tuple(range(1, feature_levels[-1] + 1)) self.feature_levels = feature_levels net = ptcv_get_model(name, pretrained=pretrained) del net.output net = net.features self.layer1 = net.init_block.conv self.layer2 = nn.Sequential( net.init_block.pool, net.stage1, ) self.layer3 = net.stage2 self.layer4 = net.stage3 if hasattr(net, "post_activ"): self.layer5 = nn.Sequential( net.stage4, net.post_activ, ) else: self.layer5 = net.stage4 self.out_channels = [ calc_out_channels(getattr(self, ("layer%d" % i))) for i in feature_levels ]
def main(): # prepare input data trf = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) inputs = trf(Image.open('./data/dog.jpg')).unsqueeze(0) # load existing model from pytorchcv lib (pretrain=False) net = ptcv_get_model('mobilenetv2_w1', pretrained=False) net.eval() output = net(inputs) # print("original model:",net) # fuse the Batch Normalization net1 = fuse_bn_recursively(copy.deepcopy(net)) net1.eval() output1 = net1(inputs) # print("BN fusion model:",net1) # compare the output print("output of original model:",output.size()) print("=> min : %.4f, mean : %.4f max : %.4f"%(output.min().detach().numpy(),output.mean().detach().numpy(),output.max().detach().numpy())) print("output of BNfusion model:",output1.size()) print("=> min : %.4f, mean : %.4f max : %.4f"%(output1.min().detach().numpy(),output1.mean().detach().numpy(),output1.max().detach().numpy())) # transform to ONNX format for visualization dummy_input = Variable(torch.randn([1, 3, 224, 224])) torch.onnx.export(net, dummy_input, "./data/mobilenet_v2.onnx") torch.onnx.export(net1, dummy_input, "./data/mobilenet_v2_nobn.onnx")
def resnet(dataset: str, depth: int, pretrained=False) -> Module: """ Wrapper for (basic) renset available in the pytorchcv package. More variants are availble through the general wrapper. :param dataset: One of cifar10, cifar100, svhn, imagenet. :param depth: depth of the architecture, one of (10, 12, 14, 16, 18, 26, 34, 50, 101, 152, 200) for imagenet, (20, 56, 110, 1001, 1202) for the other datasets. :param pretrained: loads model pretrained on `dataset`. """ if dataset in ["cifar10", "cifar100", "svhn"]: available_depths = [20, 56, 110, 1001, 1202] model_name = f"resnet{depth}_{dataset}" elif dataset == "imagenet": available_depths = [10, 12, 14, 16, 18, 26, 34, 50, 101, 152, 200] model_name = f"resnet{depth}" else: raise ValueError(f"Unrecognized dataset {dataset}") if depth not in available_depths: raise ValueError(f"Depth {depth} not available for dataset {dataset}, " f"availble depths are {available_depths}") model = ptcv_get_model(model_name, pretrained=pretrained) return model
def __init__(self, width_mult=2.0, feature_levels=(3, 4, 5), pretrained=True, include_final=False): super().__init__() _check_levels(feature_levels) self.forward_levels = tuple(range(1, feature_levels[-1] + 1)) self.feature_levels = feature_levels self.include_final = include_final name = self.mult2name[float(width_mult)] net = ptcv_get_model(name, pretrained=pretrained) del net.output net = net.features self.layer1 = net.init_block self.layer2 = net.stage1 self.layer3 = net.stage2 self.layer4 = net.stage3 if include_final: self.layer51 = net.stage4 self.layer52 = net.final_block else: self.layer5 = net.stage4 out_channels = [ net.stage1[-1].activ.num_parameters, net.stage2[-1].activ.num_parameters, net.stage3[-1].activ.num_parameters, net.final_block.conv2.conv.out_channels if include_final else net.stage4[-1].activ.num_parameters, ] self.out_channels = [out_channels[i - 2] for i in feature_levels]
def __init__(self, classCount): super(Xception_osmr, self).__init__() self.model_ft = ptcv_get_model("xception", pretrained=True) num_ftrs = self.model_ft.output.in_features self.model_ft.features.final_block.pool = nn.AdaptiveAvgPool2d((1, 1)) self.model_ft.output = nn.Sequential( nn.Linear(num_ftrs, classCount, bias=True), nn.Sigmoid())
def efficientnet_b1(pretrained=True): """ Returns efficientnet-b1 feature extraction layers, using pytorchcv's ptcv_get_model helper method. Args: pretrained --> type:bool (default: True) """ return ptcv_get_model("efficientnet_b1", pretrained=pretrained).features
def init_weights(self, num_layers): # pretrained model for ShuffleNetV2 BaseNodes # url = model_urls['shufflenetv2_x1.0'] # pretrained_state_dict = model_zoo.load_url(url) # print('=> loading pretrained model {}'.format(url)) # # modified_dict = {} # for key, value in pretrained_state_dict.items(): # modified_key = key.replace("stage2", "layer1") \ # .replace("stage3", "layer2").replace("stage4", "layer3") \ # .replace("branch", "b").replace("conv1", "layer0").replace("conv5", "layer4") # modified_dict[modified_key] = value # print(self.load_state_dict(modified_dict, strict=False)) # if self.w2 == True: # # self-defined pretrained model for Wide ShuffleNetV2 BaseNodes # pretrained_state_dict = torch.load('/rscratch/' # 'zhendong/yaohuic/CenterNet/src/pretrain_logs/shufflenetv2_w2_512_trial1/model_best.pth.tar')['state_dict'] # print('=> loading self-defined wide ShuffleNetV2 pretrained model') # else: # # self-defined pretrained model for ShuffleNetV2 BaseNodes # pretrained_state_dict = torch.load('/rscratch/' # 'zhendong/yaohuic/CenterNet/src/pretrain_logs/shufflenetv2_1_512_trial1/model_best.pth.tar')['state_dict'] # print('=> loading self-defined pretrained model') # # modified_dict = {} # for key, value in pretrained_state_dict.items(): # modified_key = key.replace('module.', '').replace("stage2", "layer1") \ # .replace("stage3", "layer2").replace("stage4", "layer3") \ # .replace("branch", "b").replace("conv1", "layer0").replace("conv5", "layer4") # modified_dict[modified_key] = value # print(self.load_state_dict(modified_dict, strict=False)) # pretrained PyTorchCV model for ShuffleNetV2 BaseNodes if self.w2 == True: model_name = "shufflenetv2_w2" else: model_name = "shufflenetv2_w1" pretrained_state_dict = ptcv_get_model(model_name, pretrained=True).state_dict() print('=> loading PyTorchCV pretrained model {}'.format(model_name)) modified_dict = {} for key, value in pretrained_state_dict.items(): modified_key = key.replace("features.stage1.", "layer1.") \ .replace("features.stage2.", "layer2.").replace("features.stage3.", "layer3.") \ .replace("unit1.", "0.").replace("unit2.", "1.").replace("unit3.", "2.") \ .replace("unit4.", "3.").replace("unit5.", "4.").replace("unit6.", "5.") \ .replace("unit7.", "6.").replace("unit8.", "7.") \ .replace("compress_layer0", "b2.0") \ .replace("dw_conv2", "b2.3").replace("compress_bn1", "b2.1") \ .replace("dw_bn2", "b2.4").replace("compress_conv1", "b2.0") \ .replace("expand_conv3", "b2.5").replace("expand_bn3", "b2.6") \ .replace("dw_conv4", "b1.0").replace("dw_bn4", "b1.1") \ .replace("expand_conv5", "b1.2").replace("expand_bn5", "b1.3") \ .replace("features.final_block.conv", "layer4.0").replace("features.final_block.bn", "layer4.1") \ .replace("features.init_block.conv.conv", "layer0.0").replace("features.init_block.conv.bn", "layer0.1") modified_dict[modified_key] = value print(self.load_state_dict(modified_dict, strict=False))
def __init__(self, version='b0', feature_levels=(3, 4, 5), pretrained=True, **kwargs): super().__init__() _check_levels(feature_levels) self.forward_levels = tuple(range(1, feature_levels[-1] + 1)) self.feature_levels = feature_levels name = 'efficientnet_%sc' % version backbone = ptcv_get_model(name, pretrained=pretrained) del backbone.output features = backbone.features self._kernel_sizes = [3] self._strides = [2] self.layer1 = nn.Sequential( features.init_block.conv, features.stage1, features.stage2.unit1.conv1, ) self._kernel_sizes.append(features.stage2.unit1.kernel_size) self._strides.append(features.stage2.unit1.stride) self.layer2 = nn.Sequential( features.stage2.unit1.conv2, features.stage2.unit1.se, features.stage2.unit1.conv3, features.stage2[1:], features.stage3.unit1.conv1, ) self._kernel_sizes.append(features.stage3.unit1.kernel_size) self._strides.append(features.stage3.unit1.stride) self.layer3 = nn.Sequential( features.stage3.unit1.conv2, features.stage3.unit1.se, features.stage3.unit1.conv3, features.stage3[1:], features.stage4.unit1.conv1, ) self._kernel_sizes.append(features.stage4.unit1.kernel_size) self._strides.append(features.stage4.unit1.stride) self.layer4 = nn.Sequential( features.stage4.unit1.conv2, features.stage4.unit1.se, features.stage4.unit1.conv3, features.stage4[1:], features.stage5.unit1.conv1, ) self._kernel_sizes.append(features.stage5.unit1.kernel_size) self._strides.append(features.stage5.unit1.stride) self.layer5 = nn.Sequential(features.stage5.unit1.conv2, features.stage5.unit1.se, features.stage5.unit1.conv3, features.stage5[1:], features.final_block) self.out_channels = np.array([ get_out_channels(getattr(self, ("layer%d" % i))) for i in feature_levels ])
def load_network(teacher=True): if args.teacher_arch == 'densenet' and teacher : net = ptcv_get_model("densenet40_k36_bc_cifar10", pretrained=True) net = ReturnLayers(net).to(device) elif args.teacher_arch == 'wrn' and teacher : net_checkpoint = torch.load('checkpoints/wrn_40_2_T.t7') start_epoch = net_checkpoint['epoch'] net = WideResNet(net_checkpoint['depth'], net_checkpoint['width'], num_classes=net_checkpoint['num_classes'], dropRate=0).to(device) net.load_state_dict(net_checkpoint['state']) elif args.teacher_arch == 'darts' and teacher and not args.fisher and not args.fisher_teacher: net_checkpoint = torch.load('checkpoints/%s.t7' % args.teacher_checkpoint) genotype = eval("genotypes.%s" % args.std_arch) net = Network(args.init_channels, num_classes, args.teach_depth, args.auxiliary, genotype).to(device) net.load_state_dict(net_checkpoint['state']) elif args.teacher_arch == 'darts' and teacher and args.fisher: net = rank_at_param_goal(args.std_arch, args.init_channels, 10, 10, args.auxiliary, \ args.cifar_loc, args.batch_size, 100, args.dataset, args.param_goal, args.teacher_checkpoint) elif args.teacher_arch == 'darts' and teacher and args.fisher_teacher: net_checkpoint = torch.load('checkpoints/%s.t7' % args.teacher_checkpoint) genotype = eval("genotypes.%s" % args.std_arch) net = Network(args.init_channels, num_classes, args.student_depth, args.auxiliary, genotype).to(device) with open(args.groups_file, 'r+') as f: groups = f.readlines() group = 0 for cell in net.cells: for op in cell._ops: if isinstance(op, SepConv) or isinstance(op, DilConv): op.update(int(groups[group])) group +=1 net.drop_path_prob = 0.2 data = torch.rand(2,3,32,32).cuda() net(data) net.load_state_dict(net_checkpoint['state']) elif args.student_arch == 'densenet' and not teacher : net = ptcv_get_model("densenet100_k12_bc_cifar10", pretrained=False) net = ReturnLayers(net).to(device) elif args.student_arch == 'wrn' and not teacher : net = WideResNet(args.student_depth, args.student_width, num_classes=num_classes, dropRate=0).to(device) elif args.student_arch == 'darts' and not teacher: genotype = eval("genotypes.%s" % args.std_arch) net = Network(args.init_channels, num_classes, args.student_depth, args.auxiliary, genotype).to(device) net.drop_path_prob = 0.2 return net
def resattnet56(in_channels=3, num_classes=1000, pretrained=True): model = ptcv_get_model("resattnet56", pretrained=False) if pretrained is True: state = torch.hub.load_state_dict_from_url( "https://github.com/phamquiluan/ResidualAttentionNetwork/releases/download/v0.1.0/resattnet56.pth" ) model.load_state_dict(state["state_dict"]) model.output = nn.Linear(2048, num_classes) return model
def __init__(self, version='b0', feature_levels=(3, 4, 5), pretrained=True, frozen_stages=-1, **kwargs): super().__init__() self.feature_levels = feature_levels self.frozen_stages = frozen_stages name = 'efficientnet_%sc' % version backbone = ptcv_get_model(name, pretrained=pretrained) del backbone.output features = backbone.features self._kernel_sizes = [3] self._strides = [2] self.layer1 = nn.Sequential( features.init_block.conv, features.stage1, features.stage2.unit1.conv1, ) self._kernel_sizes.append(features.stage2.unit1.kernel_size) self._strides.append(features.stage2.unit1.stride) self.layer2 = nn.Sequential( features.stage2.unit1.conv2, features.stage2.unit1.se, features.stage2.unit1.conv3, features.stage2[1:], features.stage3.unit1.conv1, ) self._kernel_sizes.append(features.stage3.unit1.kernel_size) self._strides.append(features.stage3.unit1.stride) self.layer3 = nn.Sequential( features.stage3.unit1.conv2, features.stage3.unit1.se, features.stage3.unit1.conv3, features.stage3[1:], features.stage4.unit1.conv1, ) self._kernel_sizes.append(features.stage4.unit1.kernel_size) self._strides.append(features.stage4.unit1.stride) self.layer4 = nn.Sequential( features.stage4.unit1.conv2, features.stage4.unit1.se, features.stage4.unit1.conv3, features.stage4[1:], features.stage5.unit1.conv1, ) self._kernel_sizes.append(features.stage5.unit1.kernel_size) self._strides.append(features.stage5.unit1.stride) self.layer5 = nn.Sequential(features.stage5.unit1.conv2, features.stage5.unit1.se, features.stage5.unit1.conv3, features.stage5[1:], features.final_block) self._freeze_stages()
def main(): args = parse_args() cfg = Config.fromfile(args.config) logger = get_logger(cfg.log_level) # init distributed environment if necessary if args.launcher == 'none': dist = False logger.info('Disabled distributed training.') else: dist = True init_dist(**cfg.dist_params) world_size = torch.distributed.get_world_size() rank = torch.distributed.get_rank() if rank != 0: logger.setLevel('ERROR') logger.info('Enabled distributed training.') try: dataset = getattr(data, cfg.dataset_type) train_loader, val_loader = dataset(cfg.data_root, batch_size = cfg.total_bs, imgsize=cfg.img_size) except: print("Dataset Type {} are Not Implemented. ") exit() # build model try: model = ptcv_get_model(cfg.model.type, pretrained=cfg.model.pretrained) except: print("Model Not Implemented. ") exit() if dist: model = DistributedDataParallel(model.cuda(), device_ids=[torch.cuda.current_device()]) else: model = DataParallel(model, device_ids=cfg.gpus).cuda() # build runner and register hooks runner = Runner(model,batch_processor,cfg.optimizer,cfg.work_dir,log_level=cfg.log_level) runner.register_training_hooks( lr_config=cfg.lr_config, optimizer_config=cfg.optimizer_config, checkpoint_config=cfg.checkpoint_config, log_config=cfg.log_config) if dist: runner.register_hook(DistSamplerSeedHook()) # load param (if necessary) and run if cfg.get('resume_from') is not None: runner.resume(cfg.resume_from) elif cfg.get('load_from') is not None: runner.load_checkpoint(cfg.load_from) runner.run([train_loader, val_loader], cfg.workflow, cfg.total_epochs)
def __init__(self, num_classes, pretrained=True, size=224): super(PretrainedMobilenetWD4, self).__init__() self.size = size mobilenet = ptcv_get_model("mobilenet_wd4", pretrained=pretrained) if self.size == 224: self.model = nn.Sequential(*(list(mobilenet.children())[0])) else: self.model = nn.Sequential(*(list(mobilenet.children())[0][:-1])) self.avgpool = nn.AvgPool2d(int(self.size / 32), stride=1) self.last_fc = nn.Linear(256, num_classes)
def cbam_resnet50(in_channels, num_classes, pretrained=1): if pretrained==1: model = ptcv_get_model("cbam_resnet50", pretrained=True) model.output = nn.Linear(2048, num_classes) print('using pretrained imagenet weights') else: model = ptcv_get_model("cbam_resnet50", pretrained=False) model.output = nn.Linear(2048, num_classes) if pretrained==2: print('using pretrained lfw weights') state_dict = torch.load('saved/checkpoints/cbam_resnet50__n_2021Apr20_00.24')['net'] model.load_state_dict(state_dict) # freeze params # for name,param in model.named_parameters(): # if "stage4" not in name: # param.requires_grad = False # model.output = nn.Linear(2048, num_classes) # model.output = nn.Sequential(nn.Dropout(p=0.5, inplace=False), nn.Linear(2048, num_classes)) return model
def __init__(self, num_classes, pretrained=True, size=224): super(PretrainedSeresNext50, self).__init__() self.size = size seresnext50 = ptcv_get_model("seresnext50_32x4d", pretrained=pretrained) if self.size == 224: self.model = nn.Sequential(*(list(seresnext50.children())[0])) else: self.model = nn.Sequential(*(list(seresnext50.children())[0][:-1])) self.avgpool = nn.AvgPool2d(int(self.size / 32), stride=1) self.last_fc = nn.Linear(2048, num_classes)
def __init__(self, feature_levels=(3, 4, 5), pretrained=False, **kwargs): super().__init__() _check_levels(feature_levels) self.forward_levels = tuple(range(1, feature_levels[-1] + 1)) self.out_levels = feature_levels if pretrained: net = ptcv_get_model("darknet53", pretrained=True) del net.output net = net.features self.layer1 = nn.Sequential( net.init_block, net.stage1, ) self.layer2 = net.stage2 self.layer3 = net.stage3 self.layer4 = net.stage4 self.layer5 = net.stage5 else: backbone = BDarknet(num_classes=1, **kwargs) del backbone.fc self.layer1 = nn.Sequential( backbone.conv0, backbone.down1, backbone.layer1, ) self.layer2 = nn.Sequential( backbone.down2, backbone.layer2, ) self.layer3 = nn.Sequential( backbone.down3, backbone.layer3, ) self.layer4 = nn.Sequential( backbone.down4, backbone.layer4, ) self.layer5 = nn.Sequential( backbone.down5, backbone.layer5, ) self.out_channels = [ get_out_channels(getattr(self, ("layer%d" % i))) for i in feature_levels ]
def maskrcnn_inceptionresnetv2_rpn(num_classes=2): backbone = ptcv_get_model("InceptionResNetV2", pretrained=True).features backbone.out_channels = 1536 anchor_generator = AnchorGenerator(sizes=((128, 256, 512, 768), ), aspect_ratios=((0.5, 1.0, 2.0), )) model = MaskRCNN( backbone, num_classes=num_classes, # transform parameters min_size=800, max_size=1333, image_mean=None, image_std=None, # RPN parameters rpn_anchor_generator=anchor_generator, rpn_head=None, rpn_pre_nms_top_n_train=2000, rpn_pre_nms_top_n_test=1000, rpn_post_nms_top_n_train=2000, rpn_post_nms_top_n_test=1000, rpn_nms_thresh=0.7, rpn_fg_iou_thresh=0.7, rpn_bg_iou_thresh=0.3, rpn_batch_size_per_image=256, rpn_positive_fraction=0.5, # Box parameters box_roi_pool=None, box_head=None, box_predictor=None, box_score_thresh=0.05, box_nms_thresh=0.5, box_detections_per_img=100, box_fg_iou_thresh=0.5, box_bg_iou_thresh=0.5, box_batch_size_per_image=512, box_positive_fraction=0.25, bbox_reg_weights=None, # Mask parameters mask_roi_pool=None, mask_head=None, mask_predictor=None) return model