def __init__(self): super().__init__() # pretrained encoder self.backbone = models.densenet169(pretrained=True) # do not train encoder for param in self.backbone.parameters(): param.requires_grad = False
def densenet169(num_classes=1000, pretrained='imagenet'): r"""Densenet-169 model from `"Densely Connected Convolutional Networks" <https://arxiv.org/pdf/1608.06993.pdf>` """ model = models.densenet169(pretrained=False) if pretrained is not None: settings = pretrained_settings['densenet169'][pretrained] model = load_pretrained(model, num_classes, settings) return model
def create_dense169(load_weights=False): desnet_ft = models.densenet169(pretrained=True) num_ftrs = desnet_ft.classifier.in_features desnet_ft.classifier = nn.Linear(num_ftrs, 17) desnet_ft = desnet_ft.cuda() desnet_ft.name = 'dense169' #desnet_ft.batch_size = 32 return desnet_ft
def get_backbone(name, pretrained=True): """ Loading backbone, defining names for skip-connections and encoder output. """ # TODO: More backbones if name == 'resnet18': backbone = models.resnet50(pretrained=pretrained) elif name == 'resnet34': backbone = models.resnet34(pretrained=pretrained) elif name == 'resnet50': backbone = models.resnet50(pretrained=pretrained) elif name == 'resnet101': backbone = models.resnet101(pretrained=pretrained) elif name == 'resnet152': backbone = models.resnet152(pretrained=pretrained) elif name == 'vgg16': backbone = models.vgg16_bn(pretrained=pretrained).features elif name == 'vgg19': backbone = models.vgg19_bn(pretrained=pretrained).features # elif name == 'inception_v3': # backbone = models.inception_v3(pretrained=pretrained, aux_logits=False) elif name == 'densenet121': backbone = models.densenet121(pretrained=True).features elif name == 'densenet161': backbone = models.densenet161(pretrained=True).features elif name == 'densenet169': backbone = models.densenet169(pretrained=True).features elif name == 'densenet201': backbone = models.densenet201(pretrained=True).features else: raise NotImplemented( '{} backbone model is not implemented so far.'.format(name)) if name.startswith('resnet'): feature_names = [None, 'relu', 'layer1', 'layer2', 'layer3'] backbone_output = 'layer4' elif name == 'vgg16': # TODO: consider using a 'bridge' for VGG models, there is just a MaxPool between last skip and backbone output feature_names = ['5', '12', '22', '32', '42'] backbone_output = '43' elif name == 'vgg19': feature_names = ['5', '12', '25', '38', '51'] backbone_output = '52' # elif name == 'inception_v3': # feature_names = [None, 'Mixed_5d', 'Mixed_6e'] # backbone_output = 'Mixed_7c' elif name.startswith('densenet'): feature_names = [ None, 'relu0', 'denseblock1', 'denseblock2', 'denseblock3' ] backbone_output = 'denseblock4' else: raise NotImplemented( '{} backbone model is not implemented so far.'.format(name)) return backbone, feature_names, backbone_output
def __init__(self, layers=None, pretrained=True, memory_efficient=False, first_avg_pool=False): densenet = densenet169(pretrained=pretrained, memory_efficient=memory_efficient) strides = [2, 4, 8, 16, 32] channels = [64, 128, 256, 640, 1664] super().__init__(densenet, strides, channels, layers, first_avg_pool)
def densenet169(): densenet = models.densenet169(pretrained=True) densenet.eval() for batch in 1, 2, 4, 8, 16, 32: filename = 'densenet169i' + str(batch) + '.onnx' print(filename) torch.onnx.export(densenet, torch.randn(batch, 3, 224, 224), filename, keep_initializers_as_inputs=True)
def densenet169(num_classes=1000, pretrained='imagenet'): r"""Densenet-169 model from `"Densely Connected Convolutional Networks" <https://arxiv.org/pdf/1608.06993.pdf>` """ model = models.densenet169(pretrained=False) if pretrained is not None: settings = pretrained_settings['densenet169'][pretrained] model = load_pretrained(model, num_classes, settings) model = modify_densenets(model) return model
def __init__(self, sample_rate: int, window_size: int, hop_size: int, mel_bins: int, fmin: int, fmax: int, classes_num: int, apply_aug: bool, top_db=None): super().__init__() window = 'hann' center = True pad_mode = 'reflect' ref = 1.0 amin = 1e-10 self.interpolate_ratio = 32 # Downsampled ratio self.apply_aug = apply_aug # Spectrogram extractor self.spectrogram_extractor = Spectrogram(n_fft=window_size, hop_length=hop_size, win_length=window_size, window=window, center=center, pad_mode=pad_mode, freeze_parameters=True) # Logmel feature extractor self.logmel_extractor = LogmelFilterBank(sr=sample_rate, n_fft=window_size, n_mels=mel_bins, fmin=fmin, fmax=fmax, ref=ref, amin=amin, top_db=top_db, freeze_parameters=True) # Spec augmenter self.spec_augmenter = SpecAugmentation(time_drop_width=64, time_stripes_num=2, freq_drop_width=8, freq_stripes_num=2) self.bn0 = nn.BatchNorm2d(mel_bins) self.fc1 = nn.Linear(1664, 1024, bias=True) self.att_block = AttBlock(1024, classes_num, activation='sigmoid') self.init_weight() self.densenet_features = models.densenet169(pretrained=True).features
def build_model(self, model_path, num_classes=40): # create model model = models.densenet169(num_classes=40) modelState = torch.load(model_path, map_location='cpu') d = OrderedDict() for key, value in modelState.items(): tmp = key[7:] d[tmp] = value model.load_state_dict(d) return model
def initialize_model(model_name, num_classes, feature_extract, use_pretrained=True): # Initialize these variables which will be set in this if statement. Each of these # variables is model specific. model_ft = None input_size = 0 if model_name == "resnet": """ Resnet18, resnet34, resnet50, resnet101 """ model_ft = models.resnet50(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.fc.in_features model_ft.fc = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "vgg": """ VGG11_bn """ model_ft = models.vgg11_bn(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.classifier[6].in_features model_ft.classifier[6] = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "densenet": """ Densenet169 """ model_ft = models.densenet169(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.classifier.in_features model_ft.classifier = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "inception": """ Inception v3 Be careful, expects (299,299) sized images and has auxiliary output """ model_ft = models.inception_v3(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) # Handle the auxilary net num_ftrs = model_ft.AuxLogits.fc.in_features model_ft.AuxLogits.fc = nn.Linear(num_ftrs, num_classes) # Handle the primary net num_ftrs = model_ft.fc.in_features model_ft.fc = nn.Linear(num_ftrs, num_classes) input_size = 299 else: print("Invalid model name, exiting...") exit() return model_ft, input_size
def get_net(net_name, weight_path=None): """ 根据网络名称获取模型 :param net_name: 网络名称 :param weight_path: 与训练权重路径 :return: """ pretrain = weight_path is None # 没有指定权重路径,则加载默认的预训练权重 if net_name in ['vgg16']: net = models.vgg16(pretrained=pretrain) elif net_name == 'vgg19': net = models.vgg19(pretrained=pretrain) elif net_name in ['resnet18']: net = models.resnet18(pretrained=pretrain) elif net_name in ['frcnn']: net = models.frcnn(pretrained=pretrain) elif net_name in ['resnet50']: net = models.resnet50(pretrained=pretrain) elif net_name == 'resnet101': net = models.resnet101(pretrained=pretrain) elif net_name in ['densenet121']: net = models.densenet121(pretrained=pretrain) elif net_name in ['densenet169']: net = models.densenet169(pretrained=pretrain) elif net_name in ['inception']: net = models.inception_v3(pretrained=pretrain) elif net_name in ['mobilenet_v2']: net = models.mobilenet_v2(pretrained=pretrain) elif net_name in ['shufflenet_v2']: net = models.shufflenet_v2_x1_0(pretrained=pretrain) elif net_name == 'efficientnet': net = EfficientNet.from_name('efficientnet-b0') feature = net._fc.in_features net._fc = nn.Linear(in_features=feature, out_features=2, bias=True) # 修改分类层结构 net.load_state_dict(torch.load("efficientNet-b0.pt")) # 加载CT集上训练参数 else: raise ValueError('invalid network name:{}'.format(net_name)) # 加载指定路径的权重参数 if weight_path is not None and net_name.startswith('densenet'): pattern = re.compile( r'^(.*denselayer\d+\.(?:norm|relu|conv))\.((?:[12])\.(?:weight|bias|running_mean|running_var))$' ) state_dict = torch.load(weight_path) for key in list(state_dict.keys()): res = pattern.match(key) if res: new_key = res.group(1) + res.group(2) state_dict[new_key] = state_dict[key] del state_dict[key] net.load_state_dict(state_dict) elif weight_path is not None: net.load_state_dict(torch.load(weight_path)) return net
def model_fn(model_dir): logger.info('Loading the model.') with open(os.path.join(model_dir, 'model_data.json')) as json_file: data = json.load(json_file) n_classes = data['num_classes'] model = models.densenet169(pretrained=False, num_classes = n_classes) model.load_state_dict(torch.load(os.path.join(model_dir, 'model.pth'),map_location=torch.device('cpu') )) model.to('cpu') logger.info('Done loading model') return {'model': model, 'data': data}
def __init__(self, pretrained=True): super(MyModel_dnet169, self).__init__() self.cnn = models.densenet169(pretrained=pretrained) self.bn1 = nn.BatchNorm1d(1000) self.dr1 = nn.Dropout(p=0.25, inplace=False) self.fc1 = nn.Linear(1000 + 1, 512) self.r1 = nn.ReLU(inplace=True) self.bn2 = nn.BatchNorm1d(512) self.dr2 = nn.Dropout(p=0.5, inplace=False) self.fc2 = nn.Linear(512, 3)
def densenet169(num_classes, pretrained=True, freeze=False): model = models.densenet169(pretrained=pretrained) if freeze: model = freeze_all_layers(model) num_features = model.classifier.in_features model.classifier = nn.Linear(num_features, num_classes) model = Add_Sigmoid(model) return model, 'Densenet169'
def init_delf_pca(): model_ft = models.densenet169(pretrained=True) features = list(model_ft.children())[:-1] features.append(nn.ReLU(inplace=True)) features.append(AttentionPool(1664)) model = nn.Sequential(*features) model = nn.DataParallel(model) model_pca = nn.Sequential(*list(model.children()), nn.Linear(1664, 768)) return model_pca
def __init__(self, num_channel=21, classCount=2, isTrained=True): super(DenseNet169, self).__init__() self.first_conv = nn.Sequential( nn.Conv2d(num_channel, 3, kernel_size=3, padding=1), nn.BatchNorm2d(3)) densenet = models.densenet169(pretrained=isTrained) self.features = densenet.features kernelCount = densenet.classifier.in_features self.classifier = nn.Sequential(nn.Linear(kernelCount, classCount))
def __init__(self, num_class=1): super().__init__() self.channels = 1664 densenet_169 = models.densenet169(pretrained=True) for params in densenet_169.parameters(): params.requires_grad_(False) self.conv1 = nn.Conv2d(in_channels=2, out_channels=3, kernel_size=4) self.features = nn.Sequential(*list(densenet_169.features.children())) self.relu = nn.ReLU(inplace=True) self.fc1 = nn.Linear(self.channels, num_class) self.sigmoid = nn.Sigmoid()
def create_model(device, ema=False): model = models.densenet169(pretrained=True) ft = model.classifier.in_features model.classifier = torch.nn.Linear(ft, 7) model = model.to(device) if ema: for param in model.parameters(): param.detach_() return model
def delf_densenet169(): model_ft = models.densenet169(pretrained=True) features = list(model_ft.children())[:-1] features.append(nn.ReLU(inplace=True)) features.append(AttentionPool(1664)) # features.append(list(model_ft.children())[-1]) delf_model = nn.Sequential(*features) return delf_model
def create_dense169(load_weights=False): desnet_ft = models.densenet169(pretrained=True) num_ftrs = desnet_ft.classifier.in_features desnet_ft.classifier = nn.Linear(num_ftrs, 3) print(num_ftrs) desnet_ft = desnet_ft.cuda() w_file = MODEL_DIR + '/dense169.pth' if load_weights: load_weights_file(desnet_ft, w_file) desnet_ft.name = 'dense169' return desnet_ft, w_file
def __init__(self): super(MydenseNet169, self).__init__() model = models.densenet169(pretrained=True) self.resnet_lay = nn.Sequential(*list(model.children())[:-1]) self.conv1_lay = nn.Conv2d(1664, 512, kernel_size=(1, 1), stride=(1, 1)) self.relu1_lay = nn.ReLU(inplace=True) self.drop_lay = nn.Dropout2d(0.5) self.global_average = nn.AdaptiveAvgPool2d((1, 1)) self.fc_Linear_lay2 = nn.Linear(512, 2)
def _load_model(name='squeezenet'): if name in _models_to_use: return _models_to_use[name] if name == 'densenet': net = _models_to_use[name] = models.densenet169(pretrained=True) elif name == 'squeezenet': net = _models_to_use[name] = models.squeezenet1_1(pretrained=True) else: print('Unknown model name, using squeezenet') net = _models_to_use[name] = models.squeezenet1_1(pretrained=True) net._modules.get('features').register_forward_hook(_hook_feature) return net
def main(opt): train_dataset = mura_data(lists =opt['train_path'], transform = tf_train) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=opt['batch_size'], shuffle=True,num_workers=3) test_dataset = mura_data(lists =opt['test_path'], train = False, transform = tf_test) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=opt['batch_size'], shuffle=False,num_workers=3) model = densenet169(pretrained='/root/workspace/pre_models/densenet169.pth') model.fc = torch.nn.Linear(1664,1) model.to(device) optimizer = torch.optim.Adam( model.parameters(),lr=opt['lr'], weight_decay=1e-3) # optimizer = torch.optim.SGD( # model.parameters(),lr=opt['lr'], weight_decay=1e-4) binary_loss_fn = torch.nn.BCEWithLogitsLoss(weight=None) start_epoch = 1 results = {'loss':10,'kappa':0,'train':[],'test':[],'loss_list':[],'kappa_list':[]} for epoch in range(start_epoch, opt['num_epochs']): #utils.normalize_batch(x) if opt['decay_epochs']: adjust_learning_rate(optimizer, epoch, initial_lr=opt['lr'], decay_epochs=opt['decay_epochs']) train_metrics = train_epoch(epoch, model, train_loader, optimizer, binary_loss_fn) eval_metrics,out_list = val(model, test_loader, binary_loss_fn,opt['test_path']) results['train'].append(train_metrics) results['test'].append(eval_metrics) if eval_metrics[1]<results['loss']: results['loss'] = eval_metrics[1] results['loss_list'] = out_list if epoch>1: model.cpu() torch.save(model.state_dict(), opt['out_dir']+'.th') print('save to %s'%opt['out_dir']) model.to(device) if eval_metrics[-2]>results['kappa']: results['kappa'] = eval_metrics[-2] results['kappa_list'] = out_list if epoch>1: model.cpu() torch.save(model.state_dict(), opt['out_dir']+'_kappa.th') print('save to %s'%opt['out_dir']) model.to(device) x = open(opt['out_dir']+'.pkl','wb') pickle.dump(results,x) x.close()
def densenet169(input_shape=(1, 128, 128)): model = models.densenet169(pretrained=False) model.features.conv0 = nn.Conv2d( in_channels=input_shape[0], out_channels=64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False ) model.classifier = nn.Linear(in_features=1664, out_features=80) return model
def __init__( self, in_channels, out_channels, ): super(DenseNet_pytorch, self).__init__() # self.model = models.resnet34(pretrained=False) self.model = models.densenet169(pretrained=False) # self.model.load_state_dict(torch.load(Windows_filepath+'densenet169-b2777c0a.pth')) self.conv0 = self.model.features.conv0 self.norm0 = self.model.features.norm0 self.relu0 = self.model.features.relu0 self.pool0 = self.model.features.pool0 ############# Block1-down 64-64 ############## self.dense_block1 = self.model.features.denseblock1 self.trans_block1 = self.model.features.transition1 ############# Block2-down 32-32 ############## self.dense_block2 = self.model.features.denseblock2 self.trans_block2 = self.model.features.transition2 ############# Block3-down 16-16 ############## self.dense_block3 = self.model.features.denseblock3 self.trans_block3 = self.model.features.transition3 ############# Block4-down 16-16 ############## self.dense_block4 = self.model.features.denseblock4 self.model_out = self.model.features.norm5 self.model_relu = F.relu self.in_channels = in_channels self.out_channels = out_channels self.model_out_channels = 1664 self.midconv = nn.Conv2d(in_channels=self.model_out_channels, out_channels=self.model_out_channels, kernel_size=1, stride=1, padding=0, bias=True) # self.midrelu = nn.LeakyReLU(0.2,inplace=True) # 输出:1664 self.up1 = Upproject(1920, 832) self.up2 = Upproject(960, 416) self.up3 = Upproject(480, 208) self.up4 = Upproject(272, 104) self.finalconv = nn.Conv2d(in_channels=104, out_channels=1, kernel_size=3, stride=1, padding=1, bias=True)
def create_dense169(load_weights=False, freeze=False): desnet_ft = models.densenet169(pretrained=True) if freeze: for param in desnet_ft.parameters(): param.requires_grad = False num_ftrs = desnet_ft.classifier.in_features desnet_ft.classifier = nn.Sequential(nn.Linear(num_ftrs, 1), nn.Sigmoid()) desnet_ft = desnet_ft.cuda() desnet_ft.name = 'dense169' #desnet_ft.batch_size = 32 return desnet_ft
def __init__(self, backbone, expert_dims, backbone_pretrain, same_dim=512, feat2d=False): super(ImageCEModule, self).__init__() modalities = list(expert_dims.keys()) self.expert_dims = expert_dims self.modalities = modalities self.backbone_name = backbone self.feat2d = feat2d # -------- Backbone --------------------------------------------------- if backbone == 'resnet': resnet = models.resnet50(pretrained=True) modules = list(resnet.children())[:-2] self.backbone = nn.Sequential(*modules) elif backbone == 'resnet152': resnet = models.resnet152(pretrained=True) modules = list(resnet.children())[:-2] self.backbone = nn.Sequential(*modules) elif backbone == 'densenet': densenet = models.densenet169(pretrained=True) modules = list(densenet.children())[:-1] self.backbone = nn.Sequential(*modules) else: raise ValueError ## Load deepfashion pretrained backbone if backbone_pretrain == "deepfashion": print("Load %s_%s as backbone" % (backbone_pretrain, backbone)) param_dict = torch.load( 'deepfashion/logdir/%s_%s/best_ckpt.pth.tar' % (backbone_pretrain, backbone))['state_dict'] for i in param_dict: if "backbone." in i: self.backbone.state_dict()[i[9:]].copy_(param_dict[i]) if backbone == 'densenet': self.backbone = self.backbone[0] self.dropout = nn.Dropout(p=0.2) self.avg_pooling = nn.AdaptiveAvgPool2d((1, 1)) # ------ Embedding for modalities ------------------------------------- vis_embed_dict = {} for key in modalities: vis_embed_dict[key] = nn.Sequential( nn.Linear(expert_dims[key], same_dim), nn.ReLU() # NoReLU ) #vis_embed_dict[key] = ReduceDim(expert_dims[key], same_dim) self.vis_embed = nn.ModuleDict(vis_embed_dict)
def get_feat_model(self, feature_model, read_type): if read_type == 'RGB': num_input_features = 3 else: num_input_features = 1 #copy_opt = Namespace(**vars(self.opt)) feat_model = None if feature_model == 'attention': feat_model = AttentionNetwork(self.opt, num_input_features) elif feature_model == 'densenet169': feat_model = models.densenet169(pretrained=not self.opt.no_densenet_pretrain) feat_model.classifier = nn.Linear(feat_model.classifier.in_features, self.opt.feat_size) return feat_model
def __init__(self, num_classes, pretrained=True, fine_tune=False): super(DenseNetClassifier, self).__init__() self.densenet = densenet169(pretrained) self._num_classes = num_classes set_parameter_requires_grad(self.densenet, True) self._build_last_layer() self.densenet.features.conv0 = torch.nn.Conv2d(6, 64, kernel_size=7, stride=2, padding=3) torch.nn.init.xavier_uniform_(self.densenet.features.conv0.weight)
def init_densenet169(): model_ft = models.densenet169(pretrained=True) # num_ftrs = model_ft.classifier.in_features # model_ft.classifier = nn.Linear(num_ftrs, 2000) features = list(model_ft.children())[:-1] features.append(nn.ReLU(inplace=True)) features.append(Pool(1664)) # features.append(list(model_ft.children())[-1]) model_ft = nn.Sequential(*features) return model_ft
def prepare_densenet(is_pre_trained, fine_tune, num_classes): model = models.densenet169( pretrained=is_pre_trained, num_classes=1000 if is_pre_trained else num_classes) if fine_tune: frozen = nn.Sequential(*[model.features[i] for i in range(4)]) set_parameter_requires_grad(frozen) model.classifier = nn.Linear(model.classifier.in_features, num_classes) return model
def dn169(pre): return children(densenet169(pre))[0] def dn201(pre): return children(densenet201(pre))[0]
def dn169(pre): return children(densenet169(pre))[0] @_fastai_model('Densenet-201', 'Densely Connected Convolutional Networks',