def __init__(self, num_classes, pretrained="imagenet"):
super().__init__()
self.net = senet154(pretrained=pretrained)
self.net.avg_pool = AdaptiveConcatPool2d()
self.net.last_linear = nn.Sequential(Flatten(), SEBlock(2048 * 2),
nn.Dropout(),
nn.Linear(2048 * 2, num_classes))
def __init__(self, num_classes, senet154_weight, nchannels=[256,512,1024,2048], multi_scale = False ,learn_region=True, use_gpu=True):
super(MODEL,self).__init__()
self.learn_region=learn_region
self.use_gpu = use_gpu
self.conv = ConvBlock(3, 32, 3, s=2, p=1)
self.senet154_weight = senet154_weight
self.multi_scale = multi_scale
self.num_classes = num_classes
# construct SEnet154
senet154_ = senet154(num_classes=1000, pretrained=None)
senet154_.load_state_dict(torch.load(self.senet154_weight))
self.extract_feature = senet154_.layer0
#global backbone
self.global_layer1 = senet154_.layer1
self.global_layer2 = senet154_.layer2
self.global_layer3 = senet154_.layer3
self.global_layer4 = senet154_.layer4
self.classifier_global =nn.Sequential(
nn.Linear(2048*2, 2048), # To merge 4 areas into one, batchnormal 1d, and relu need to be added
nn.BatchNorm1d(2048),
nn.ReLU(),
nn.Dropout(0.2), #prevent overfitting
nn.Linear(2048, num_classes),
)
if self.multi_scale:
self.global_fc = nn.Sequential(
nn.Linear(2048+512+1024, 2048), # To merge 4 areas into one, batchnormal 1d, and relu need to be added
nn.BatchNorm1d(2048),
nn.ReLU(),
)
self.global_out = nn.Linear(2048,num_classes) # global classification
else:
self.global_out = nn.Linear(2048,num_classes) # global classification
self.ha2 = HarmAttn(nchannels[1]) #R
self.ha3 = HarmAttn(nchannels[2]) #G
self.ha4 = HarmAttn(nchannels[3]) #B
self.dropout = nn.Dropout(0.2) # Use dropout before classification layer
#LocFL
if self.learn_region:
self.init_scale_factors()
self.local_conv1 = InceptionB(nchannels[1], nchannels[1])
self.local_conv2 = InceptionB(nchannels[2], nchannels[2])
self.local_conv3 = InceptionB(nchannels[3], nchannels[3])
self.local_fc = nn.Sequential(
nn.Linear(2048+512+1024, 2048), # 将4个区域 融合成一个 需要加上batchnorma1d, 和 relu
nn.BatchNorm1d(2048),
nn.ReLU(),
)
self.classifier_local = nn.Linear(2048,num_classes)
def __init__(self, num_classes=1):
super(model154_DeepSupervion, self).__init__()
self.num_classes = num_classes
self.encoder = senet154()
self.relu = nn.ReLU(inplace=True)
self.conv1 = nn.Sequential(
self.encoder.layer0.conv1, self.encoder.layer0.bn1,
self.encoder.layer0.relu1, self.encoder.layer0.conv2,
self.encoder.layer0.bn2, self.encoder.layer0.relu2,
self.encoder.layer0.conv3, self.encoder.layer0.bn3,
self.encoder.layer0.relu3)
self.conv2 = self.encoder.layer1
self.conv3 = self.encoder.layer2
self.conv4 = self.encoder.layer3
self.conv5 = self.encoder.layer4
self.center_global_pool = nn.AdaptiveAvgPool2d([1, 1])
self.center_conv1x1 = nn.Conv2d(512 * 4, 64, kernel_size=1)
self.center_fc = nn.Linear(64, 2)
self.center = nn.Sequential(
nn.Conv2d(512 * 4, 512, kernel_size=3, padding=1),
nn.BatchNorm2d(512), nn.ReLU(inplace=True),
nn.Conv2d(512, 256, kernel_size=3, padding=1), nn.BatchNorm2d(256),
nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2))
self.dec5_1x1 = nn.Sequential(nn.Conv2d(512 * 4, 512, kernel_size=1),
nn.BatchNorm2d(512),
nn.ReLU(inplace=True))
self.decoder5 = Decoder_bottleneck(256 + 512, 512, 64)
self.dec4_1x1 = nn.Sequential(nn.Conv2d(256 * 4, 256, kernel_size=1),
nn.BatchNorm2d(256),
nn.ReLU(inplace=True))
self.decoder4 = Decoder_bottleneck(64 + 256, 256, 64)
self.dec3_1x1 = nn.Sequential(nn.Conv2d(128 * 4, 128, kernel_size=1),
nn.BatchNorm2d(128),
nn.ReLU(inplace=True))
self.decoder3 = Decoder_bottleneck(64 + 128, 128, 64)
self.dec2_1x1 = nn.Sequential(nn.Conv2d(64 * 4, 64, kernel_size=1),
nn.BatchNorm2d(64),
nn.ReLU(inplace=True))
self.decoder2 = Decoder_bottleneck(64 + 64, 64, 64)
self.decoder1 = Decoder_bottleneck(64, 32, 64)
self.logits_no_empty = nn.Sequential(
nn.Conv2d(320, 64, kernel_size=3, padding=1),
nn.ReLU(inplace=True), nn.Conv2d(64, 1, kernel_size=1, padding=0))
self.logits_final = nn.Sequential(
nn.Conv2d(320 + 64, 64, kernel_size=3, padding=1),
nn.ReLU(inplace=True), nn.Conv2d(64, 1, kernel_size=1, padding=0))
def define_model(is_resnet, is_densenet, is_senet):
if is_resnet:
original_model = resnet.resnet50(pretrained = True)
Encoder = modules.E_resnet(original_model)
model = net.model(Encoder, num_features=2048, block_channel = [256, 512, 1024, 2048])
if is_densenet:
original_model = densenet.densenet161(pretrained=True)
Encoder = modules.E_densenet(original_model)
model = net.model(Encoder, num_features=2208, block_channel = [192, 384, 1056, 2208])
if is_senet:
original_model = senet.senet154(pretrained='imagenet')
Encoder = modules.E_senet(original_model)
model = net.model(Encoder, num_features=2048, block_channel = [256, 512, 1024, 2048])
return model
def __init__(self, pretrained='imagenet', **kwargs):
super(SeNet154_Unet_Double, self).__init__()
encoder_filters = [128, 256, 512, 1024, 2048]
decoder_filters = np.asarray([48, 64, 96, 160, 320])
self.conv6 = ConvRelu(encoder_filters[-1], decoder_filters[-1])
self.conv6_2 = ConvRelu(decoder_filters[-1] + encoder_filters[-2],
decoder_filters[-1])
self.conv7 = ConvRelu(decoder_filters[-1], decoder_filters[-2])
self.conv7_2 = ConvRelu(decoder_filters[-2] + encoder_filters[-3],
decoder_filters[-2])
self.conv8 = ConvRelu(decoder_filters[-2], decoder_filters[-3])
self.conv8_2 = ConvRelu(decoder_filters[-3] + encoder_filters[-4],
decoder_filters[-3])
self.conv9 = ConvRelu(decoder_filters[-3], decoder_filters[-4])
self.conv9_2 = ConvRelu(decoder_filters[-4] + encoder_filters[-5],
decoder_filters[-4])
self.conv10 = ConvRelu(decoder_filters[-4], decoder_filters[-5])
self.res = nn.Conv2d(decoder_filters[-5] * 2,
6,
1,
stride=1,
padding=0)
self._initialize_weights()
encoder = senet154(pretrained=pretrained)
# conv1_new = nn.Conv2d(9, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
# _w = encoder.layer0.conv1.state_dict()
# _w['weight'] = torch.cat([0.8 * _w['weight'], 0.1 * _w['weight'], 0.1 * _w['weight']], 1)
# conv1_new.load_state_dict(_w)
self.conv1 = nn.Sequential(encoder.layer0.conv1, encoder.layer0.bn1,
encoder.layer0.relu1, encoder.layer0.conv2,
encoder.layer0.bn2, encoder.layer0.relu2,
encoder.layer0.conv3, encoder.layer0.bn3,
encoder.layer0.relu3)
self.conv2 = nn.Sequential(encoder.pool, encoder.layer1)
self.conv3 = encoder.layer2
self.conv4 = encoder.layer3
self.conv5 = encoder.layer4
def define_model(target):
model = None
if target is 'resnet':
original_model = resnet.resnet50(pretrained=True)
encoder = modules.E_resnet(original_model)
model = net.model(encoder,
num_features=2048,
block_channel=[256, 512, 1024, 2048])
elif target is 'densenet':
original_model = densenet.densenet161(pretrained=True)
encoder = modules.E_densenet(original_model)
model = net.model(encoder,
num_features=2208,
block_channel=[192, 384, 1056, 2208])
elif target is 'senet':
original_model = senet.senet154(pretrained='imagenet')
encoder = modules.E_senet(original_model)
model = net.model(encoder,
num_features=2048,
block_channel=[256, 512, 1024, 2048])
return model
def train (pathDirData, pathFileTrain, pathFileVal, nnArchitecture, nnIsTrained, nnClassCount, trBatchSize, trMaxEpoch, transResize, transCrop, launchTimestamp, checkpoint):
#-------------------- SETTINGS: NETWORK ARCHITECTURE
if nnArchitecture == 'DENSE-NET-121': model = DenseNet121(nnClassCount, nnIsTrained).cuda()
elif nnArchitecture == 'DENSE-NET-169': model = DenseNet169(nnClassCount, nnIsTrained).cuda()
elif nnArchitecture == 'DENSE-NET-201': model = DenseNet201(nnClassCount, nnIsTrained).cuda()
elif nnArchitecture == 'RES-NET-50': model = ResNet50(nnClassCount, nnIsTrained).cuda()
#elif nnArchitecture == 'SE-RES-NET-50': model = SE_ResNet50(nnClassCount, nnIsTrained).cuda()
elif nnArchitecture == 'SE-RES-NET-50': model = senet.se_resnet50(nnClassCount, nnIsTrained).cuda()
elif nnArchitecture == 'SE-NET-154': model = senet.senet154(nnClassCount, nnIsTrained).cuda()
elif nnArchitecture == 'SE-DENSE-NET-121': model = SE_DenseNet121(nnClassCount, nnIsTrained).cuda()
model = torch.nn.DataParallel(model).cuda()
#-------------------- SETTINGS: DATA TRANSFORMS
normalize = transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
transformList = []
transformList.append(transforms.RandomResizedCrop(transCrop))
transformList.append(transforms.RandomHorizontalFlip())
transformList.append(transforms.ToTensor())
transformList.append(normalize)
transformSequence=transforms.Compose(transformList)
#-------------------- SETTINGS: DATASET BUILDERS
datasetTrain = DatasetGenerator(pathImageDirectory=pathDirData, pathDatasetFile=pathFileTrain, transform=transformSequence)
datasetVal = DatasetGenerator(pathImageDirectory=pathDirData, pathDatasetFile=pathFileVal, transform=transformSequence)
dataLoaderTrain = DataLoader(dataset=datasetTrain, batch_size=trBatchSize, shuffle=True, num_workers=24, pin_memory=True)
dataLoaderVal = DataLoader(dataset=datasetVal, batch_size=trBatchSize, shuffle=False, num_workers=24, pin_memory=True)
#-------------------- SETTINGS: OPTIMIZER & SCHEDULER
optimizer = optim.Adam (model.parameters(), lr=0.00001, betas=(0.9, 0.999), eps=1e-08, weight_decay=1e-5)
# optimizer = optim.SGD(model.parameters(), lr=0.00001, momentum=0.9, weight_decay=1e-5)
scheduler = ReduceLROnPlateau(optimizer, factor = 0.1, patience = 5, mode = 'min')
#-------------------- SETTINGS: LOSS
loss = torch.nn.BCELoss(size_average = True)
#---- Load checkpoint
if checkpoint != None:
modelCheckpoint = torch.load(checkpoint)
model.load_state_dict(modelCheckpoint['state_dict'])
optimizer.load_state_dict(modelCheckpoint['optimizer'])
#---- TRAIN THE NETWORK
lossMIN = 100000
for epochID in range (0, trMaxEpoch):
timestampTime = time.strftime("%H%M%S")
timestampDate = time.strftime("%d%m%Y")
timestampSTART = timestampDate + '-' + timestampTime
ChexnetTrainer.epochTrain (model, dataLoaderTrain, optimizer, scheduler, trMaxEpoch, nnClassCount, loss)
lossVal, losstensor = ChexnetTrainer.epochVal (model, dataLoaderVal, optimizer, scheduler, trMaxEpoch, nnClassCount, loss)
timestampTime = time.strftime("%H%M%S")
timestampDate = time.strftime("%d%m%Y")
timestampEND = timestampDate + '-' + timestampTime
scheduler.step(losstensor.data[0])
if lossVal < lossMIN:
lossMIN = lossVal
torch.save({'epoch': epochID + 1, 'state_dict': model.state_dict(), 'best_loss': lossMIN, 'optimizer' : optimizer.state_dict()}, 'm-' + launchTimestamp + '.pth.tar')
print ('Epoch [' + str(epochID + 1) + '] [save] [' + timestampEND + '] loss= ' + str(lossVal))
else:
print ('Epoch [' + str(epochID + 1) + '] [----] [' + timestampEND + '] loss= ' + str(lossVal))
def test (pathDirData, pathFileTest, pathModel, nnArchitecture, nnClassCount, nnIsTrained, trBatchSize, transResize, transCrop, launchTimeStamp):
CLASS_NAMES = [ 'Atelectasis', 'Cardiomegaly', 'Effusion', 'Infiltration', 'Mass', 'Nodule', 'Pneumonia',
'Pneumothorax', 'Consolidation', 'Edema', 'Emphysema', 'Fibrosis', 'Pleural_Thickening', 'Hernia']
cudnn.benchmark = True
#-------------------- SETTINGS: NETWORK ARCHITECTURE, MODEL LOAD
if nnArchitecture == 'DENSE-NET-121': model = DenseNet121(nnClassCount, nnIsTrained).cuda()
elif nnArchitecture == 'DENSE-NET-169': model = DenseNet169(nnClassCount, nnIsTrained).cuda()
elif nnArchitecture == 'DENSE-NET-201': model = DenseNet201(nnClassCount, nnIsTrained).cuda()
elif nnArchitecture == 'RES-NET-50': model = ResNet50(nnClassCount, nnIsTrained).cuda()
#elif nnArchitecture == 'SE-RES-NET-50': model = SE_ResNet50(nnClassCount, nnIsTrained).cuda()
elif nnArchitecture == 'SE-RES-NET-50': model = senet.se_resnet50(nnClassCount, nnIsTrained).cuda()
elif nnArchitecture == 'SE-NET-154': model = senet.senet154(nnClassCount, nnIsTrained).cuda()
elif nnArchitecture == 'SE-DENSE-NET-121': model = SE_DenseNet121(nnClassCount, nnIsTrained).cuda()
model = torch.nn.DataParallel(model).cuda()
modelCheckpoint = torch.load(pathModel)
model.load_state_dict(modelCheckpoint['state_dict'])
#-------------------- SETTINGS: DATA TRANSFORMS, TEN CROPS
normalize = transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
#-------------------- SETTINGS: DATASET BUILDERS
transformList = []
transformList.append(transforms.Resize(transResize))
transformList.append(transforms.TenCrop(transCrop))
transformList.append(transforms.Lambda(lambda crops: torch.stack([transforms.ToTensor()(crop) for crop in crops])))
transformList.append(transforms.Lambda(lambda crops: torch.stack([normalize(crop) for crop in crops])))
transformSequence=transforms.Compose(transformList)
datasetTest = DatasetGenerator(pathImageDirectory=pathDirData, pathDatasetFile=pathFileTest, transform=transformSequence)
dataLoaderTest = DataLoader(dataset=datasetTest, batch_size=trBatchSize, num_workers=8, shuffle=False, pin_memory=True)
outGT = torch.FloatTensor().cuda()
outPRED = torch.FloatTensor().cuda()
model.eval()
for i, (input, target) in enumerate(dataLoaderTest):
target = target.cuda()
outGT = torch.cat((outGT, target), 0)
bs, n_crops, c, h, w = input.size()
varInput = torch.autograd.Variable(input.view(-1, c, h, w).cuda(), volatile=True)
out = model(varInput)
outMean = out.view(bs, n_crops, -1).mean(1)
outPRED = torch.cat((outPRED, outMean.data), 0)
aurocIndividual = ChexnetTrainer.computeAUROC(outGT, outPRED, nnClassCount)
aurocMean = np.array(aurocIndividual).mean()
print ('AUROC mean ', aurocMean)
for i in range (0, len(aurocIndividual)):
print (CLASS_NAMES[i], ' ', aurocIndividual[i])
return
