def __init__(self, smg_config=None):
if not smg_config:
smg_config = defaultconfig
self.cammodel = DenseNet(block_config=(6, 12, 48, 32), num_classes=4)
self.gbpmodel = DenseNet(block_config=(6, 12, 48, 32), num_classes=4)
self.cammodel.load_state_dict(
torch.load(smg_config["pretrain_path"],
map_location='cpu')["state_dict"])
self.gbpmodel.load_state_dict(
torch.load(smg_config["pretrain_path"],
map_location='cpu')["state_dict"])
self.cammodel.eval()
self.gbpmodel.eval()
self.gradcam = GradCam(self.cammodel, "features.denseblock4",
smg_config["use_cuda"])
self.guidebp = GuidedBackpropReLUModel(self.gbpmodel,
smg_config["use_cuda"])
self.useunet = False
if smg_config["unet_path"]:
self.useunet = True
self.unet = UNet(3, 3)
self.unet.load_state_dict(
torch.load(smg_config["unet_path"], map_location='cpu'))
self.unet.eval()
if smg_config["use_cuda"]:
self.unet.cuda()
def densenet169(pretrained=False, model_path=None, **kwargs):
r"""Densenet-169 model from
`"Densely Connected Convolutional Networks" <https://arxiv.org/pdf/1608.06993.pdf>`_
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
"""
model = DenseNet(num_init_features=64,
growth_rate=32,
block_config=(6, 12, 32, 32),
**kwargs)
if pretrained:
# '.'s are no longer allowed in module names, but pervious _DenseLayer
# has keys 'norm.1', 'relu.1', 'conv.1', 'norm.2', 'relu.2', 'conv.2'.
# They are also in the checkpoints in model_urls. This pattern is used
# to find such keys.
pattern = re.compile(
r'^(.*denselayer\d+\.(?:norm|relu|conv))\.((?:[12])\.(?:weight|bias|running_mean|running_var))$'
)
if model_path is not None:
state_dict = torch.load(model_path)
else:
state_dict = model_zoo.load_url(model_urls['densenet169'])
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]
model.load_state_dict(state_dict)
return model
def DENSENets(arch, cfg, model_path):
"""
自定义接口 for model_factory
:param arch: dense121, dense201, dense161, dense264
:param cfg: arch configs
:param model_path: state_dict.pth
:return: a blank model or pre-trained model
"""
pattern = re.compile(
r'^(.*denselayer\d+\.(?:norm|relu|conv))\.'
r'((?:[12])\.(?:weight|bias|running_mean|running_var))$')
model = DenseNet(**cfg)
state_dict = {}
if os.path.isfile(model_path):
print('\n=> loading model.pth from %s.' % model_path)
state_dict = torch.load(model_path)
elif model_path == 'download':
print('\n=> downloading model.pth from %s.' % model_urls[arch])
state_dict = model_zoo.load_url(model_urls[arch])
else:
assert model_path == '', '<model_path> must refer to valid-model.ckpt || ' 'download' ' || "".'
if state_dict:
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]
model.load_state_dict(state_dict)
print('\nSuccess: loaded model.pth from %s.\n' % model_path)
return model
def densenet161(num_classes=17, pretrained=False):
model = DenseNet(num_init_features=96,
growth_rate=48,
block_config=(6, 12, 36, 24),
num_classes=num_classes)
if pretrained:
# load model dictionary
model_dict = model.state_dict()
# load pretrained model
pretrained_dict = model_zoo.load_url(model_urls['densenet161'])
# update model dictionary using pretrained model without classifier layer
model_dict.update({
key: pretrained_dict[key]
for key in pretrained_dict.keys() if 'classifier' not in key
})
model.load_state_dict(model_dict)
return model
def __init__(self):
super(DenseNetModel, self).__init__()
self.dense_net = DenseNet(growth_rate=32,
block_config=(6, 12, 32, 32),
num_classes=2)
self.criterion = nn.CrossEntropyLoss()
def test_pytorch():
import torch
from torchvision.models import DenseNet
model = DenseNet()
t = torch.randn(1, 3, 224, 224)
out = model(t)
assert out.shape[1] == 1000
def __init__(self, NUM_CLASSES):
super(DenseNet201, self).__init__()
self.model_name = "DenseNet201"
self.model = DenseNet(
num_init_features=64,
growth_rate=32,
block_config=(6, 12, 48, 32),
num_classes=NUM_CLASSES,
)
def __init__(self, NUM_CLASSES):
super(DenseNet161, self).__init__()
self.model_name = "DenseNet161"
self.model = DenseNet(
num_init_features=96,
growth_rate=48,
block_config=(6, 12, 36, 24),
num_classes=NUM_CLASSES,
)
def dn_bc_100_12_fc():
model = DenseNet(growth_rate=12,
block_config=(16, 16, 16),
num_init_features=24,
num_classes=100)
conv = nn.Conv2d(3, 24, kernel_size=3, padding=1, bias=False)
nn.init.kaiming_normal_(conv.weight)
model.features.conv0 = conv
del model.features.norm0, model.features.relu0
return model
def densenet161(pretrained=False, **kwargs):
if pretrained:
model = DenseNet(num_init_features=96,
growth_rate=48,
block_config=(6, 12, 36, 24),
**kwargs)
pattern = re.compile(
r'^(.*denselayer\d+\.(?:norm|relu|conv))\.((?:[12])\.(?:weight|bias|running_mean|running_var))$'
)
pretrained_state_dict = torch.load(
'./Authority/densenet161-8d451a50.pth'
) # load_url函数根据model_urls字典下载或导入相应的预训练模型
for key in list(pretrained_state_dict.keys()):
res = pattern.match(key)
if res:
new_key = res.group(1) + res.group(2)
pretrained_state_dict[new_key] = pretrained_state_dict[key]
del pretrained_state_dict[key]
now_state_dict = model.state_dict() # 返回model模块的字典
pretrained_state_dict.pop('classifier.weight')
pretrained_state_dict.pop('classifier.bias')
now_state_dict.update(pretrained_state_dict)
model.load_state_dict(now_state_dict)
# 最后通过调用model的load_state_dict方法用预训练的模型参数来初始化你构建的网络结构，
# 这个方法就是PyTorch中通用的用一个模型的参数初始化另一个模型的层的操作。load_state_dict方法还有一个重要的参数是strict，
# 该参数默认是True，表示预训练模型的层和你的网络结构层严格对应相等（比如层名和维度）
return model
return DenseNet(num_init_features=96,
growth_rate=48,
block_config=(6, 12, 36, 24),
**kwargs)
class SalientMapGenerator:
def __init__(self, smg_config=None):
if not smg_config:
smg_config = defaultconfig
self.cammodel = DenseNet(block_config=(6, 12, 48, 32), num_classes=4)
self.gbpmodel = DenseNet(block_config=(6, 12, 48, 32), num_classes=4)
self.cammodel.load_state_dict(
torch.load(smg_config["pretrain_path"],
map_location='cpu')["state_dict"])
self.gbpmodel.load_state_dict(
torch.load(smg_config["pretrain_path"],
map_location='cpu')["state_dict"])
self.cammodel.eval()
self.gbpmodel.eval()
self.gradcam = GradCam(self.cammodel, "features.denseblock4",
smg_config["use_cuda"])
self.guidebp = GuidedBackpropReLUModel(self.gbpmodel,
smg_config["use_cuda"])
self.useunet = False
if smg_config["unet_path"]:
self.useunet = True
self.unet = UNet(3, 3)
self.unet.load_state_dict(
torch.load(smg_config["unet_path"], map_location='cpu'))
self.unet.eval()
if smg_config["use_cuda"]:
self.unet.cuda()
def __call__(self, data):
cam = self.gradcam(data)
cam /= np.max(cam)
gbp = self.guidebp(data)
gbp = torch.sum(gbp, 0).detach().numpy()
gbp /= np.max(gbp)
sm = 3 * gbp + 2 * cam
if self.useunet:
seg = self.unet(data).cpu()
seg = torch.sum(seg, 1)[0].detach().numpy()
seg /= np.max(seg)
sm += seg
sm /= np.max(sm)
return sm
def __init__(self,
growth_rate=32,
block_config=(6, 12, 24, 16),
num_init_features=64,
bn_size=4,
drop_rate=0.2,
num_classes=14):
super(LungXnet, self).__init__()
self.model = DenseNet(growth_rate=growth_rate,
block_config=block_config,
num_init_features=num_init_features,
bn_size=bn_size,
drop_rate=drop_rate,
num_classes=num_classes)
self.n_filters = self.model.classifier.in_features
self.model.classifier = nn.Sequential(
OrderedDict([('linear', nn.Linear(self.n_filters, num_classes)),
('sigmoid', nn.Sigmoid())]))
def load_model(model_path):
device = torch.device('cuda')
checkpoint = torch.load(model_path,
map_location=lambda storage, loc: storage)
# load checkpoint to CPU and then put to device https://discuss.pytorch.org/t/saving-and-loading-torch-models-on-2-machines-with-different-number-of-gpu-devices/6666
model = DenseNet(growth_rate=checkpoint["growth_rate"],
block_config=checkpoint["block_config"],
num_init_features=checkpoint["num_init_features"],
bn_size=checkpoint["bn_size"],
drop_rate=checkpoint["drop_rate"],
num_classes=checkpoint["num_classes"]).to(device)
model.load_state_dict(checkpoint["model_dict"])
print(
f"total params: \t{sum([np.prod(p.size()) for p in model.parameters()])}"
)
model.eval()
return model, device
es = s / (percent + .00001)
rs = es - s
return '%s (- %s)' % (asMinutes(s), asMinutes(rs))
#specify if we should use a GPU (cuda) or only the CPU
print(torch.cuda.get_device_properties(gpuid))
torch.cuda.set_device(gpuid)
device = torch.device(f'cuda:{gpuid}' if torch.cuda.is_available() else 'cpu')
# +
#build the model according to the paramters specified above and copy it to the GPU. finally print out the number of trainable parameters
model = DenseNet(growth_rate=growth_rate,
block_config=block_config,
num_init_features=num_init_features,
bn_size=bn_size,
drop_rate=drop_rate,
num_classes=num_classes).to(device)
#model = DenseNet(growth_rate=32, block_config=(6, 12, 24, 16), #these represent the default parameters
# num_init_features=64, bn_size=4, drop_rate=0, num_classes=3)
print(
f"total params: \t{sum([np.prod(p.size()) for p in model.parameters()])}")
# -
#this defines our dataset class which will be used by the dataloader
class Dataset(object):
def __init__(self, fname, img_transform=None):
#nothing special here, just internalizing the constructor parameters
OUTPUT_DIR = args.outdir
resize = args.resize
batch_size = args.batchsize
patch_size = args.patchsize
stride_size = patch_size//2
# ----- load network
device = torch.device(args.gpuid if args.gpuid!=-2 and torch.cuda.is_available() else 'cpu')
checkpoint = torch.load(args.model, map_location=lambda storage, loc: storage) #load checkpoint to CPU and then put to device https://discuss.pytorch.org/t/saving-and-loading-torch-models-on-2-machines-with-different-number-of-gpu-devices/6666
model = DenseNet(growth_rate=checkpoint["growth_rate"], block_config=checkpoint["block_config"],
num_init_features=checkpoint["num_init_features"], bn_size=checkpoint["bn_size"],
drop_rate=checkpoint["drop_rate"], num_classes=checkpoint["num_classes"]).to(device)
model.load_state_dict(checkpoint["model_dict"])
model.eval()
print(f"total params: \t{sum([np.prod(p.size()) for p in model.parameters()])}")
# ----- get file list
if not os.path.exists(OUTPUT_DIR):
os.makedirs(OUTPUT_DIR)
files = []
basepath = args.basepath #
basepath = basepath + os.sep if len(