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