def __init__(self, num_classes): super(InceptionResNetV2, self).__init__() self.name = "InceptionResNetV2" self.model = model_zoo.inceptionresnetv2() cfg.mean = self.model.mean cfg.std = self.model.std self.fc = nn.Linear(1536, num_classes)
def generate_C2D_model(opt): if opt.c2d_model_name == 'inception_v3': C, H, W = 3, 299, 299 model = pretrainedmodels.inceptionv3(num_classes=1000, pretrained='imagenet') load_image_fn = utils.LoadTransformImage(model) elif opt.c2d_model_name == 'resnet152': C, H, W = 3, 224, 224 model = pretrainedmodels.resnet152(num_classes=1000, pretrained='imagenet') load_image_fn = utils.LoadTransformImage(model) elif opt.c2d_model_name == 'inception_v4': C, H, W = 3, 299, 299 model = pretrainedmodels.inceptionv4(num_classes=1000, pretrained='imagenet') load_image_fn = utils.LoadTransformImage(model) elif opt.c2d_model_name == 'inceptionresnetv2': C, H, W = 3, 299, 299 model = pretrainedmodels.inceptionresnetv2(num_classes=1000, pretrained='imagenet') load_image_fn = utils.LoadTransformImage(model) model.last_linear = utils.Identity() if not opt.no_cuda: model = model.to(opt.device) return load_image_fn, model, (C, H, W)
def __init__(self, num_classes=1001): super(InceptionResNetV2, self).__init__() # Modules self.conv2d_1a = BasicConv2d(3, 32, kernel_size=3, stride=2) self.conv2d_2a = BasicConv2d(32, 32, kernel_size=3, stride=1) self.conv2d_2b = BasicConv2d(32, 64, kernel_size=3, stride=1, padding=1) self.maxpool_3a = nn.MaxPool2d(3, stride=2) self.conv2d_3b = BasicConv2d(64, 80, kernel_size=1, stride=1) self.conv2d_4a = BasicConv2d(80, 192, kernel_size=3, stride=1) self.maxpool_5a = nn.MaxPool2d(3, stride=2) self.mixed_5b = Mixed_5b() self.repeat = self._make_layer(Block35, scale=0.17, blocks=10) self.mixed_6a = Mixed_6a() self.repeat_1 = self._make_layer(Block17, scale=0.10, blocks=20) self.mixed_7a = Mixed_7a() self.repeat_2 = self._make_layer(Block8, scale=0.20, blocks=9) self.block8 = Block8(noReLU=True) self.conv2d_7b = BasicConv2d(2080, 1536, kernel_size=1, stride=1) self.avgpool_1a = nn.AvgPool2d(8, count_include_pad=False) # load pre_train model pre_model = pretrainedmodels.inceptionresnetv2(num_classes=1000, pretrained='imagenet') self.last_linear = pre_model.last_linear self.load_state_dict(pre_model.state_dict()) self.last_linear = nn.Linear(1536, num_classes) init_params(self.last_linear)
def __init__(self): super().__init__() self.pad = torch.nn.ConstantPad2d(24, -1) self.base_model = pretrainedmodels.inceptionresnetv2() self.base_model.conv2d_1a.conv = nn.Conv2d(1, 32, kernel_size=3, stride=2, padding=1, bias=False)
def __init__(self, n_class=10, pretrained='imagenet'): super(InceptionResnetv2, self).__init__() model = pretrainedmodels.inceptionresnetv2(n_class=1000, pretrained=pretrained) self.features = model.features self.avgpool = model.avgpool_1a for child in self.features.children(): for p in child.parameters(): p.requires_grad = False self.fc = nn.Linear(2048, n_class)
def __init__(self, num_classs=100): super(Modified_InceptionResnetV2, self).__init__() model = pretrainedmodels.inceptionresnetv2(num_classes=1000, pretrained='imagenet') self.num_classs = num_classs temp = [] for i, m in enumerate(model.children()): if i <= 15: temp.append(m) else: self.classifier = nn.Linear(in_features=1536, out_features=num_classs) self.features = nn.Sequential(*temp)
def test_inceptionresnetv2_model(input_var, pool, assert_equal_outputs): original_model = pretrainedmodels.inceptionresnetv2(pretrained='imagenet', num_classes=1000) finetune_model = make_model( 'inceptionresnetv2', num_classes=1000, pool=pool, pretrained=True, ) copy_module_weights(original_model.last_linear, finetune_model._classifier) assert_equal_outputs(input_var, original_model, finetune_model)
def __init__(self, input_size=128, num_classes=340, pretrained='imagenet', dropout=0.): super().__init__() self.model = inceptionresnetv2(num_classes=1000, pretrained=pretrained) self.features = self.model.features self.relu = nn.ReLU() self.avg_pool = nn.AvgPool2d(input_size // 64, stride=1, padding=0) self.dropout = nn.Dropout(p=dropout) self.last_linear = nn.Linear(1536, num_classes)
def nets(model, num_class): if model == 'inceptionv4': model = ptm.inceptionv4(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Linear(model.last_linear.in_features, num_class) return model if model == 'senet154': model = ptm.senet154(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Linear(model.last_linear.in_features, num_class) return model if model == 'pnasnet': model = ptm.pnasnet5large(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Linear(model.last_linear.in_features, num_class) return model if model == 'xception': model = ptm.xception(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Linear(model.last_linear.in_features, num_class) return model if model == 'incepresv2': model = ptm.inceptionresnetv2(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Linear(model.last_linear.in_features, num_class) return model if model == 'resnet152': model = models.resnet152(pretrained=True) model.fc = nn.Linear(2048, num_class) return model if model == 'se_resxt101': model = ptm.se_resnext101_32x4d(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Linear(model.last_linear.in_features, num_class) return model if model == 'nasnet': model = ptm.nasnetalarge(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Linear(model.last_linear.in_features, num_class) return model if model == 'dpn': # 224 input size model = ptm.dpn107(num_classes=1000, pretrained='imagenet+5k') model.last_linear = nn.Conv2d(model.last_linear.in_channels, num_class, kernel_size=1, bias=True) return model if model == 'resnext101':# 320 input size model = torch.hub.load('facebookresearch/WSL-Images', 'resnext101_32x16d_wsl') model.fc = nn.Linear(2048, num_class) return model
def __init__(self, norm_layer, num_filters): """Creates an `FPN` instance for feature extraction. Args: num_filters: the number of filters in each output pyramid level pretrained: use ImageNet pre-trained backbone feature extractor """ super().__init__() self.inception = inceptionresnetv2(num_classes=1000, pretrained='imagenet') self.enc0 = self.inception.conv2d_1a self.enc1 = nn.Sequential( self.inception.conv2d_2a, self.inception.conv2d_2b, self.inception.maxpool_3a, ) # 64 self.enc2 = nn.Sequential( self.inception.conv2d_3b, self.inception.conv2d_4a, self.inception.maxpool_5a, ) # 192 self.enc3 = nn.Sequential( self.inception.mixed_5b, self.inception.repeat, self.inception.mixed_6a, ) # 1088 self.enc4 = nn.Sequential( self.inception.repeat_1, self.inception.mixed_7a, ) #2080 self.td1 = nn.Sequential( nn.Conv2d(num_filters, num_filters, kernel_size=3, padding=1), norm_layer(num_filters), nn.ReLU(inplace=True)) self.td2 = nn.Sequential( nn.Conv2d(num_filters, num_filters, kernel_size=3, padding=1), norm_layer(num_filters), nn.ReLU(inplace=True)) self.td3 = nn.Sequential( nn.Conv2d(num_filters, num_filters, kernel_size=3, padding=1), norm_layer(num_filters), nn.ReLU(inplace=True)) self.pad = nn.ReflectionPad2d(1) self.lateral4 = nn.Conv2d(2080, num_filters, kernel_size=1, bias=False) self.lateral3 = nn.Conv2d(1088, num_filters, kernel_size=1, bias=False) self.lateral2 = nn.Conv2d(192, num_filters, kernel_size=1, bias=False) self.lateral1 = nn.Conv2d(64, num_filters, kernel_size=1, bias=False) self.lateral0 = nn.Conv2d(32, num_filters // 2, kernel_size=1, bias=False) for param in self.inception.parameters(): param.requires_grad = False
def inceptionresnetv2( input_size=(3, 299, 299), num_classes=1000, pretrained=None): # Minimum Input size = (96,96) one is must above than 97 model = models.inceptionresnetv2(num_classes=1000, pretrained=pretrained) if input_size != (3, 299, 299): model.conv2d_1a.conv = nn.Conv2d(input_size[0], 32, kernel_size=(3, 3), stride=(2, 2), bias=False) model.input_size = input_size # calculate last avgpool_1a kernel size test_tensor = torch.randn(1, input_size[0], input_size[1], input_size[2]) x = model.conv2d_1a(test_tensor) x = model.conv2d_2a(x) x = model.conv2d_2b(x) x = model.maxpool_3a(x) x = model.conv2d_3b(x) x = model.conv2d_4a(x) x = model.maxpool_5a(x) x = model.mixed_5b(x) x = model.repeat(x) x = model.mixed_6a(x) x = model.repeat_1(x) x = model.mixed_7a(x) x = model.repeat_2(x) x = model.block8(x) x = model.conv2d_7b(x) #print(x.shape) model.avgpool_1a = nn.AvgPool2d(kernel_size=(x.shape[2], x.shape[3]), padding=0) x = model.avgpool_1a(x) x = x.view(x.size(0), -1).shape[1] model.last_linear = nn.Linear(in_features=x, out_features=num_classes, bias=True) return model
def get_backbone(backbone, pretrained=True): if backbone in ['resnext50_32x4d_ssl', 'resnet18_ssl', 'resnet50_ssl', 'resnext101_32x4d_ssl']: if pretrained: model = torch.hub.load(panda_config.ARCH_TO_PRETRAINED[backbone], backbone) else: model = getattr(_models, backbone.split('_ssl')[0])(pretrained=pretrained) encoder = nn.Sequential(*list(model.children())[:-2]) in_features = model.fc.in_features elif backbone in ['resnet18', 'resnet34', 'resnet50']: pretrained = 'imagenet' if pretrained else None model = getattr(_models, backbone)(pretrained=pretrained) in_features = model.fc.in_features encoder = nn.Sequential(*list(model.children())[:-2]) elif backbone in ['se_resnext50_32x4d', 'se_resnext101_32x4d', 'se_resnet50', 'se_resnet101', 'se_resnet152']: pretrained = 'imagenet' if pretrained else None model = getattr(pretrainedmodels, backbone)(pretrained=pretrained) encoder = nn.Sequential(*list(model.children())[:-2]) in_features = model.last_linear.in_features elif backbone.startswith('efficientnet'): encoder = enet.EfficientNet.from_name(backbone) if pretrained: encoder.load_state_dict(torch.load(panda_config.ARCH_TO_PRETRAINED[backbone])) in_features = encoder._fc.in_features encoder._fc = nn.Identity() elif backbone == 'inception_resnet_v2': pretrained = 'imagenet' if pretrained else None encoder = pretrainedmodels.inceptionresnetv2(pretrained=pretrained) in_features = encoder.last_linear.in_features encoder.last_linear = nn.Identity() elif backbone == 'inception_v4': pretrained = 'imagenet' if pretrained else None encoder = pretrainedmodels.inceptionv4(pretrained=pretrained) in_features = encoder.last_linear.in_features encoder.last_linear = nn.Identity() else: raise ValueError(f'Unrecognized backbone {backbone}') return encoder, in_features
def get_inception_resnet_v2_pretrained_model(num_classes): pretrained_inception_resnet_v2 = inceptionresnetv2() pretrained_inception_resnet_v2.avgpool_1a = nn.AdaptiveAvgPool2d((1, 1)) pretrained_inception_resnet_v2.last_linear = nn.Linear(1536, num_classes) return pretrained_inception_resnet_v2
def InceptionResNetV2(num_classes, pretrained=False): if pretrained: model = inceptionresnetv2(pretrained='imagenet') model.avg_pool = nn.AdaptiveAvgPool2d(1) model.last_linear = nn.Linear(1536, num_classes) return model
if params['model'] == 'resnet101': C, H, W = 3, 224, 224 model = pretrainedmodels.resnet101(pretrained='imagenet') elif params['model'] == 'resnet152': C, H, W = 3, 224, 224 model = pretrainedmodels.resnet152(pretrained='imagenet') elif params['model'] == 'resnet18': C, H, W = 3, 224, 224 model = pretrainedmodels.resnet18(pretrained='imagenet') elif params['model'] == 'resnet34': C, H, W = 3, 224, 224 model = pretrainedmodels.resnet34(pretrained='imagenet') elif params['model'] == 'inceptionresnetv2': C, H, W = 3, 299, 299 model = pretrainedmodels.inceptionresnetv2( num_classes=1001, pretrained='imagenet+background') elif params['model'] == 'googlenet': C, H, W = 3, 224, 224 model = googlenet(pretrained=True) print(model) else: print("doesn't support %s" % (params['model'])) if params['model'] != 'googlenet': load_image_fn = utils.LoadTransformImage(model) model.last_linear = utils.Identity() else: load_image_fn = google_load() model = model.cuda()
def run(train_sets, valid_sets, idx, save_dr): batch_size = 8 imagenet_data = ImageFolder(train_sets, transform=data_transforms['train']) test_data = ImageFolder(valid_sets, transform=data_transforms['val']) data_loader = DataLoader(imagenet_data, batch_size=batch_size, shuffle=True) test_data_loader = DataLoader(test_data, batch_size=1, shuffle=True) cls_num = len(imagenet_data.class_to_idx) model = inceptionresnetv2(num_classes=1001, pretrained=None) model.load_state_dict( torch.load('/home/dsl/all_check/inceptionresnetv2-520b38e4.pth'), strict=True) model.last_linear = nn.Linear(1536, cls_num) model.cuda() state = {'learning_rate': 0.01, 'momentum': 0.9, 'decay': 0.0005} #optimizer = torch.optim.SGD(model.parameters(), state['learning_rate'], momentum=state['momentum'], #weight_decay=state['decay'], nesterov=True) optimizer = torch.optim.Adam(model.parameters(), state['learning_rate'], weight_decay=state['decay'], amsgrad=True) state['label_ix'] = imagenet_data.class_to_idx state['cls_name'] = idx state['best_accuracy'] = 0 sch = lr_scheduler.ReduceLROnPlateau(optimizer=optimizer, factor=0.9, patience=3) focal_loss = FocalLoss(gamma=2) focal_loss.cuda() def train(): model.train() loss_avg = 0.0 progress = ProgressBar() ip1_loader = [] idx_loader = [] correct = 0 for (data, target) in progress(data_loader): data, target = torch.autograd.Variable( data.cuda()), torch.autograd.Variable(target.cuda()) output = model(data) pred = output.data.max(1)[1] correct += float(pred.eq(target.data).sum()) optimizer.zero_grad() loss = focal_loss(output, target) loss.backward() optimizer.step() loss_avg = loss_avg * 0.2 + float(loss) * 0.8 print(correct, len(data_loader.dataset), loss_avg) state['train_accuracy'] = correct / len(data_loader.dataset) state['train_loss'] = loss_avg def test(): with torch.no_grad(): model.eval() loss_avg = 0.0 correct = 0 for (data, target) in test_data_loader: data, target = torch.autograd.Variable( data.cuda()), torch.autograd.Variable(target.cuda()) output = model(data) loss = F.cross_entropy(output, target) pred = output.data.max(1)[1] correct += float(pred.eq(target.data).sum()) loss_avg += float(loss) state['test_loss'] = loss_avg / len(test_data_loader.dataset) state['test_accuracy'] = correct / len( test_data_loader.dataset) print(state['test_accuracy']) best_accuracy = 0.0 for epoch in range(40): state['epoch'] = epoch train() test() sch.step(state['train_accuracy']) best_accuracy = (state['train_accuracy'] + state['test_accuracy']) / 2 if best_accuracy > state['best_accuracy']: state['best_accuracy'] = best_accuracy torch.save(model.state_dict(), os.path.join(save_dr, idx + '.pth')) with open(os.path.join(save_dr, idx + '.json'), 'w') as f: f.write(json.dumps(state)) f.flush() print(state) print("Best accuracy: %f" % state['best_accuracy']) if state['test_accuracy'] == 1 and epoch > 10: break
def main(train_root, train_csv, val_root, val_csv, test_root, test_csv, epochs, aug, model_name, batch_size, num_workers, val_samples, test_samples, early_stopping_patience, limit_data, images_per_epoch, split_id, _run): assert(model_name in ('inceptionv4', 'resnet152', 'densenet161', 'senet154', 'pnasnet5large', 'nasnetalarge', 'xception', 'squeezenet', 'resnext', 'dpn', 'inceptionresnetv2', 'mobilenetv2')) cv2.setNumThreads(0) AUGMENTED_IMAGES_DIR = os.path.join(fs_observer.dir, 'images') CHECKPOINTS_DIR = os.path.join(fs_observer.dir, 'checkpoints') BEST_MODEL_PATH = os.path.join(CHECKPOINTS_DIR, 'model_best.pth') LAST_MODEL_PATH = os.path.join(CHECKPOINTS_DIR, 'model_last.pth') RESULTS_CSV_PATH = os.path.join('results', 'results.csv') EXP_NAME = _run.meta_info['options']['--name'] EXP_ID = _run._id for directory in (AUGMENTED_IMAGES_DIR, CHECKPOINTS_DIR): os.makedirs(directory) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") if model_name == 'inceptionv4': model = ptm.inceptionv4(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Linear(model.last_linear.in_features, 2) aug['size'] = 299 aug['mean'] = model.mean aug['std'] = model.std elif model_name == 'resnet152': model = models.resnet152(pretrained=True) model.fc = nn.Linear(model.fc.in_features, 2) aug['size'] = 224 aug['mean'] = [0.485, 0.456, 0.406] aug['std'] = [0.229, 0.224, 0.225] elif model_name == 'densenet161': model = models.densenet161(pretrained=True) model.classifier = nn.Linear(model.classifier.in_features, 2) aug['size'] = 224 aug['mean'] = [0.485, 0.456, 0.406] aug['std'] = [0.229, 0.224, 0.225] elif model_name == 'senet154': model = ptm.senet154(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Linear(model.last_linear.in_features, 2) aug['size'] = model.input_size[1] aug['mean'] = model.mean aug['std'] = model.std elif model_name == 'squeezenet': model = ptm.squeezenet1_1(num_classes=1000, pretrained='imagenet') model.last_conv = nn.Conv2d( 512, 2, kernel_size=(1, 1), stride=(1, 1)) aug['size'] = model.input_size[1] aug['mean'] = model.mean aug['std'] = model.std elif model_name == 'pnasnet5large': model = ptm.pnasnet5large(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Linear(model.last_linear.in_features, 2) aug['size'] = model.input_size[1] aug['mean'] = model.mean aug['std'] = model.std elif model_name == 'nasnetalarge': model = ptm.nasnetalarge(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Linear(model.last_linear.in_features, 2) aug['size'] = model.input_size[1] aug['mean'] = model.mean aug['std'] = model.std elif model_name == 'xception': model = ptm.xception(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Linear(model.last_linear.in_features, 2) aug['size'] = model.input_size[1] aug['mean'] = model.mean aug['std'] = model.std elif model_name == 'dpn': model = ptm.dpn131(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Conv2d(model.last_linear.in_channels, 2, kernel_size=1, bias=True) aug['size'] = model.input_size[1] aug['mean'] = model.mean aug['std'] = model.std elif model_name == 'resnext': model = ptm.resnext101_64x4d(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Linear(model.last_linear.in_features, 2) aug['size'] = model.input_size[1] aug['mean'] = model.mean aug['std'] = model.std elif model_name == 'inceptionresnetv2': model = ptm.inceptionresnetv2(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Linear(model.last_linear.in_features, 2) aug['size'] = model.input_size[1] aug['mean'] = model.mean aug['std'] = model.std elif model_name == 'mobilenetv2': model = MobileNetV2() model.load_state_dict(torch.load('./auglib/models/mobilenet_v2.pth')) model.classifier = nn.Sequential( nn.Dropout(0.2), nn.Linear(model.last_channel, 2), ) aug['size'] = 224 aug['mean'] = [0.485, 0.456, 0.406] aug['std'] = [0.229, 0.224, 0.225] model.to(device) augs = Augmentations(**aug) model.aug_params = aug datasets = { 'samples': CSVDataset(train_root, train_csv, 'image_id', 'melanoma', transform=augs.tf_augment, add_extension='.jpg', limit=(400, 433)), 'train': CSVDataset(train_root, train_csv, 'image_id', 'melanoma', transform=augs.tf_transform, add_extension='.jpg', random_subset_size=limit_data), 'val': CSVDatasetWithName( val_root, val_csv, 'image_id', 'melanoma', transform=augs.tf_transform, add_extension='.jpg'), 'test': CSVDatasetWithName( test_root, test_csv, 'image_id', 'melanoma', transform=augs.tf_transform, add_extension='.jpg'), 'test_no_aug': CSVDatasetWithName( test_root, test_csv, 'image_id', 'melanoma', transform=augs.no_augmentation, add_extension='.jpg'), 'test_144': CSVDatasetWithName( test_root, test_csv, 'image_id', 'melanoma', transform=augs.inception_crop, add_extension='.jpg'), } dataloaders = { 'train': DataLoader(datasets['train'], batch_size=batch_size, shuffle=True, num_workers=num_workers, worker_init_fn=set_seeds), 'samples': DataLoader(datasets['samples'], batch_size=batch_size, shuffle=False, num_workers=num_workers, worker_init_fn=set_seeds), } save_images(datasets['samples'], to=AUGMENTED_IMAGES_DIR, n=32) sample_batch, _ = next(iter(dataloaders['samples'])) save_image(make_grid(sample_batch, padding=0), os.path.join(AUGMENTED_IMAGES_DIR, 'grid.jpg')) criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9, weight_decay=0.001) scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor=0.1, min_lr=1e-5, patience=8) metrics = { 'train': pd.DataFrame(columns=['epoch', 'loss', 'acc', 'auc']), 'val': pd.DataFrame(columns=['epoch', 'loss', 'acc', 'auc']) } best_val_auc = 0.0 best_epoch = 0 epochs_without_improvement = 0 if images_per_epoch: batches_per_epoch = images_per_epoch // batch_size else: batches_per_epoch = None for epoch in range(epochs): print('train epoch {}/{}'.format(epoch+1, epochs)) epoch_train_result = train_epoch( device, model, dataloaders, criterion, optimizer, batches_per_epoch) metrics['train'] = metrics['train'].append( {**epoch_train_result, 'epoch': epoch}, ignore_index=True) print('train', epoch_train_result) epoch_val_result, _ = test_with_augmentation( model, datasets['val'], device, num_workers, val_samples) metrics['val'] = metrics['val'].append( {**epoch_val_result, 'epoch': epoch}, ignore_index=True) print('val', epoch_val_result) print('-' * 40) scheduler.step(epoch_val_result['loss']) if epoch_val_result['auc'] > best_val_auc: best_val_auc = epoch_val_result['auc'] best_val_result = epoch_val_result best_epoch = epoch epochs_without_improvement = 0 torch.save(model, BEST_MODEL_PATH) else: epochs_without_improvement += 1 if epochs_without_improvement > early_stopping_patience: last_val_result = epoch_val_result torch.save(model, LAST_MODEL_PATH) break if epoch == (epochs-1): last_val_result = epoch_val_result torch.save(model, LAST_MODEL_PATH) for phase in ['train', 'val']: metrics[phase].epoch = metrics[phase].epoch.astype(int) metrics[phase].to_csv(os.path.join(fs_observer.dir, phase + '.csv'), index=False) # Run testing # TODO: reduce code repetition test_result, preds = test_with_augmentation( torch.load(BEST_MODEL_PATH), datasets['test'], device, num_workers, test_samples) print('[best] test', test_result) test_noaug_result, preds_noaug = test_with_augmentation( torch.load(BEST_MODEL_PATH), datasets['test_no_aug'], device, num_workers, 1) print('[best] test (no augmentation)', test_noaug_result) test_result_last, preds_last = test_with_augmentation( torch.load(LAST_MODEL_PATH), datasets['test'], device, num_workers, test_samples) print('[last] test', test_result_last) test_noaug_result_last, preds_noaug_last = test_with_augmentation( torch.load(LAST_MODEL_PATH), datasets['test_no_aug'], device, num_workers, 1) print('[last] test (no augmentation)', test_noaug_result_last) # Save predictions preds.to_csv(os.path.join(fs_observer.dir, 'test-aug-best.csv'), index=False, columns=['image', 'label', 'score']) preds_noaug.to_csv(os.path.join(fs_observer.dir, 'test-noaug-best.csv'), index=False, columns=['image', 'label', 'score']) preds_last.to_csv(os.path.join(fs_observer.dir, 'test-aug-last.csv'), index=False, columns=['image', 'label', 'score']) preds_noaug_last.to_csv(os.path.join(fs_observer.dir, 'test-noaug-last.csv'), index=False, columns=['image', 'label', 'score']) # TODO: Avoid repetition. # use ordereddict, or create a pandas df before saving with open(RESULTS_CSV_PATH, 'a') as file: file.write(','.join(( EXP_NAME, str(EXP_ID), str(split_id), str(best_epoch), str(best_val_result['loss']), str(best_val_result['acc']), str(best_val_result['auc']), str(best_val_result['avp']), str(best_val_result['sens']), str(best_val_result['spec']), str(last_val_result['loss']), str(last_val_result['acc']), str(last_val_result['auc']), str(last_val_result['avp']), str(last_val_result['sens']), str(last_val_result['spec']), str(best_val_auc), str(test_result['auc']), str(test_result_last['auc']), str(test_result['acc']), str(test_result_last['acc']), str(test_result['spec']), str(test_result_last['spec']), str(test_result['sens']), str(test_result_last['sens']), str(test_result['avp']), str(test_result_last['avp']), str(test_noaug_result['auc']), str(test_noaug_result_last['auc']), str(test_noaug_result['acc']), str(test_noaug_result_last['acc']), str(test_noaug_result['spec']), str(test_noaug_result_last['spec']), str(test_noaug_result['sens']), str(test_noaug_result_last['sens']), str(test_noaug_result['avp']), str(test_noaug_result_last['avp']), )) + '\n') return (test_noaug_result['auc'], test_result['auc'], )
def __init__(self, config_file: Optional[str] = None, override_list: List[Any] = []): _C = CN() _C.VALID_IMAGES = [ 'CXR1576_IM-0375-2001.png', 'CXR1581_IM-0378-2001.png', 'CXR3177_IM-1497-2001.png', 'CXR2585_IM-1082-1001.png', 'CXR1125_IM-0082-1001.png', 'CXR3_IM-1384-2001.png', 'CXR1565_IM-0368-1001.png', 'CXR1105_IM-0072-1001-0001.png', 'CXR2874_IM-1280-1001.png', 'CXR1886_IM-0574-1001.png' ] _C.MODELS = [{ 'resnet18': (pretrainedmodels.resnet18(pretrained=None), 512, 224), 'resnet50': (pretrainedmodels.resnet50(pretrained=None), 2048, 224), 'resnet101': (pretrainedmodels.resnet101(pretrained=None), 2048, 224), 'resnet152': (pretrainedmodels.resnet152(pretrained=None), 2048, 224), 'inception_resnet_v2': (pretrainedmodels.inceptionresnetv2(pretrained=None), 1536, 299) }] # _C.MODELS_FEATURE_SIZE = {'resnet18':512, 'resnet50':2048, 'resnet101':2048, 'resnet152':2048, # 'inception_v3':2048, 'inception_resnet_v2':1536} # Random seed for NumPy and PyTorch, important for reproducibility. _C.RANDOM_SEED = 42 # Opt level for mixed precision training using NVIDIA Apex. This can be # one of {0, 1, 2}. Refer NVIDIA Apex docs for their meaning. _C.FP16_OPT = 2 # Path to the dataset root, which structure as per README. Path is # assumed to be relative to project root. _C.IMAGE_PATH = '/netscratch/gsingh/MIMIC_CXR/DataSet/Indiana_Chest_XRay/Images_2' _C.TRAIN_JSON_PATH = '/netscratch/gsingh/MIMIC_CXR/DataSet/Indiana_Chest_XRay/iu_xray_train_2.json' _C.VAL_JSON_PATH = '/netscratch/gsingh/MIMIC_CXR/DataSet/Indiana_Chest_XRay/iu_xray_val_2.json' _C.TEST_JSON_PATH = '/netscratch/gsingh/MIMIC_CXR/DataSet/Indiana_Chest_XRay/iu_xray_test_2.json' _C.PRETRAINED_EMDEDDING = False # Path to .vocab file generated by ``sentencepiece``. _C.VOCAB_FILE_PATH = "/netscratch/gsingh/MIMIC_CXR/DataSet/Indiana_Chest_XRay/Vocab/indiana.vocab" # Path to .model file generated by ``sentencepiece``. _C.VOCAB_MODEL_PATH = "/netscratch/gsingh/MIMIC_CXR/DataSet/Indiana_Chest_XRay/Vocab/indiana.model" _C.VOCAB_SIZE = 3000 _C.EPOCHS = 1024 _C.BATCH_SIZE = 10 _C.TEST_BATCH_SIZE = 100 _C.ITERATIONS_PER_EPOCHS = 1 _C.WEIGHT_DECAY = 1e-5 _C.NUM_LABELS = 41 _C.IMAGE_SIZE = 299 _C.MAX_SEQUENCE_LENGTH = 130 _C.DROPOUT_RATE = 0.1 _C.D_HEAD = 64 _C.TRAIN_DATASET_LENGTH = 25000 _C.INFERENCE_TIME = False _C.COMBINED_N_LAYERS = 1 _C.BEAM_SIZE = 50 _C.PADDING_INDEX = 0 _C.EOS_INDEX = 3 _C.SOS_INDEX = 2 _C.USE_BEAM_SEARCH = True _C.EXTRACTED_FEATURES = False _C.IMAGE_MODEL_PATH = '/netscratch/gsingh/MIMIC_CXR/Results/Image_Feature_Extraction/MIMIC_CXR_No_ES/model.pth' _C.EMBEDDING_DIM = 8192 _C.CONTEXT_SIZE = 1024 _C.LR_COMBINED = 1e-4 _C.MAX_LR = 1e-1 _C.SAVED_DATASET = False _C.MODEL_NAME = 'inception_resnet_v2' INIT_PATH = '/netscratch/gsingh/MIMIC_CXR/Results/Modified_Transformer/Indiana_15_10_2020_2/' _C.SAVED_DATASET_PATH_TRAIN = INIT_PATH + 'DataSet/train_dataloader.pth' _C.SAVED_DATASET_PATH_VAL = INIT_PATH + 'DataSet/val_dataloader.pth' _C.SAVED_DATASET_PATH_TEST = INIT_PATH + 'DataSet/test_dataloader.pth' _C.CHECKPOINT_PATH = INIT_PATH + 'CheckPoints' _C.MODEL_PATH = INIT_PATH + 'combined_model.pth' _C.MODEL_STATE_DIC = INIT_PATH + 'combined_model_state_dic.pth' _C.FIGURE_PATH = INIT_PATH + 'Graphs' _C.CSV_PATH = INIT_PATH _C.TEST_CSV_PATH = INIT_PATH + 'test_output_image_feature_input.json' self._C = _C if config_file is not None: self._C.merge_from_file(config_file) self._C.merge_from_list(override_list) self.add_derived_params() # Make an instantiated object of this class immutable. self._C.freeze()
def create_model(model_key, pretrained, num_of_classes, use_gpu): """Create CNN model Args: model_key (str): Name of the model to be created. pretrained: If True, only train the laster layer. num_of_classes (int): Number of categories of outputs. Returns: model_conv: A defined model to be train Raises: ValueError: Error while asking an unrecognized model. """ if model_key == 'resnet18': model_conv = torchvision.models.resnet18(pretrained=True) elif model_key == 'resnet34': model_conv = torchvision.models.resnet34(pretrained=True) elif model_key == 'resnet50': model_conv = torchvision.models.resnet50(pretrained=True) elif model_key == 'resnet101': model_conv = torchvision.models.resnet101(pretrained=True) elif model_key == 'inception_v3': model_conv = torchvision.models.inception_v3(pretrained=True) elif model_key == 'inceptionresnetv2': model_conv = pretrainedmodels.inceptionresnetv2(num_classes=1000, pretrained='imagenet') elif model_key == 'inceptionv4': model_conv = pretrainedmodels.inceptionv4(num_classes=1000, pretrained='imagenet') elif model_key == 'nasnetalarge': model_conv = pretrainedmodels.nasnetalarge(num_classes=1000, pretrained='imagenet') else: raise ValueError("Unrecognized name of model {}".format(model_key)) if pretrained: # Lock parameters for transfer learning for param in model_conv.parameters(): param.requires_grad = False # Parameters of newly constructed modules have requires_grad=True by default if model_key == 'nasnetalarge' or model_key == 'inceptionresnetv2' or model_key == 'inceptionv4': dim_feats = model_conv.last_linear.in_features # 2048 model_conv.last_linear = nn.Linear(dim_feats, num_of_classes) else: num_ftrs = model_conv.fc.in_features model_conv.fc = nn.Linear(num_ftrs, num_of_classes) # Initialize newly added module parameters if model_key == 'nasnetalarge' or model_key == 'inceptionresnetv2' or model_key == 'inceptionv4': nn.init.xavier_uniform(model_conv.last_linear.weight) nn.init.constant(model_conv.last_linear.bias, 0) else: nn.init.xavier_uniform(model_conv.fc.weight) nn.init.constant(model_conv.fc.bias, 0) if use_gpu: model_conv = model_conv.cuda() return model_conv
def __init__(self, num_classes, pretrained="imagenet"): super().__init__() self.net = inceptionresnetv2(pretrained=pretrained) self.net.avgpool_1a = AdaptiveConcatPool2d() self.net.last_linear = nn.Sequential(Flatten(), SEBlock(1536 * 2), nn.Linear(1536 * 2, num_classes))
elif params['model'] == 'resnet152': C, H, W = 3, 224, 224 model = pretrainedmodels.resnet152(num_classes=1000, pretrained='imagenet') load_image_fn = utils.LoadTransformImage(model) elif params['model'] == 'inception_v4': C, H, W = 3, 299, 299 model = pretrainedmodels.inceptionv4(num_classes=1000, pretrained='imagenet') load_image_fn = utils.LoadTransformImage(model) elif params['model'] == 'inceptionresnetv2': C, H, W = 3, 299, 299 model = pretrainedmodels.inceptionresnetv2(num_classes=1000, pretrained='imagenet') load_image_fn = utils.LoadTransformImage(model) else: print("doesn't support %s" % (params['model'])) model.last_linear = utils.Identity() model = nn.DataParallel(model) model = model.to(args.device) extract_feats(params, model, load_image_fn) # 摘录来的 # class Identity(nn.Module): # # def __init__(self):
parser.add_argument('--logfile', default='result') # iterno parser.add_argument('--iterNo', default='1') args = parser.parse_args() import os os.environ["CUDA_VISIBLE_DEVICES"] = args.c model = args.model if model == 'resnet152' or model == 'resnet152_3c': original_model = torchvision.models.resnet152(pretrained=True) elif model == 'resnet50': original_model = torchvision.models.resnet50(pretrained=True) elif model == 'inceptionresnetv2': original_model = pretrainedmodels.inceptionresnetv2(pretrained='imagenet') #original_model = torchvision.models.inception_v3(pretrained=True) elif model == 'densenet161': original_model = torchvision.models.densenet161(pretrained=True) elif model == 'vgg16': original_model = torchvision.models.vgg16(pretrained=True) elif model == 'squeezenet': original_model = torchvision.models.squeezenet1_0(pretrained=True) else: sys.exit(-1) #for name, param in original_model.named_children(): # print(name) net = FineTuneModel(original_model, model) #for name, param in net.named_children(): # print(name)
def __init__(self, num_filters=256): """Creates an `FPN` instance for feature extraction. Args: num_filters: the number of filters in each output pyramid level pretrained: use ImageNet pre-trained backbone feature extractor """ super().__init__() self.inception = inceptionresnetv2(num_classes=1000, pretrained='imagenet') norm_layer = functools.partial(nn.InstanceNorm2d, affine=False, track_running_stats=True) self.enc0 = self.inception.conv2d_1a self.enc1 = nn.Sequential( self.inception.conv2d_2a, self.inception.conv2d_2b, self.inception.maxpool_3a, ) # 64 self.enc2 = nn.Sequential( self.inception.conv2d_3b, self.inception.conv2d_4a, self.inception.maxpool_5a, ) # 192 self.enc3 = nn.Sequential( self.inception.mixed_5b, self.inception.repeat, self.inception.mixed_6a, ) # 1088 self.enc4 = nn.Sequential( self.inception.repeat_1, self.inception.mixed_7a, ) # 2080 self.pad = nn.ReflectionPad2d(1) self.lateral4 = nn.Conv2d(2080, num_filters, kernel_size=1, bias=False) self.lateral3 = nn.Conv2d(1088, num_filters, kernel_size=1, bias=False) self.lateral2 = nn.Conv2d(192, num_filters, kernel_size=1, bias=False) self.lateral1 = nn.Conv2d(64, num_filters, kernel_size=1, bias=False) self.lateral0 = nn.Conv2d(32, num_filters // 2, kernel_size=1, bias=False) # # cfe2 # cfe3 self.conv21 = nn.Conv2d(1088, 32, (1, 1), padding=0) self.conv22 = nn.Conv2d(1088, 32, (3, 3), dilation=3, padding=3) self.conv23 = nn.Conv2d(1088, 32, (3, 3), dilation=5, padding=5) self.conv24 = nn.Conv2d(1088, 32, (3, 3), dilation=7, padding=7) self.bn5 = nn.BatchNorm2d(num_features=128, affine=False) # cfe4 self.conv25 = nn.Conv2d(2080, 32, (1, 1), padding=0) self.conv26 = nn.Conv2d(2080, 32, (3, 3), dilation=3, padding=3) self.conv27 = nn.Conv2d(2080, 32, (3, 3), dilation=5, padding=5) self.conv28 = nn.Conv2d(2080, 32, (3, 3), dilation=7, padding=7) self.bn6 = nn.BatchNorm2d(num_features=128, affine=False) # channel wise attention self.cha_att = ChannelwiseAttention( in_channels=256 ) #### 这里的 256 =C3:128+C4:128 128 = 32+32+32+32 这里是可以调整的 # self.linear1 = nn.Linear(256, 56) # self.linear2 = nn.Linear(56, 256) self.conv29 = nn.Conv2d(256, 256, (1, 1), padding=0) self.bn7 = nn.BatchNorm2d(num_features=256, affine=False) self.relu = nn.ReLU() for param in self.inception.parameters(): param.requires_grad = False
def train(mission_id, BATCH_SIZE, EPOCH, LR, LR_DECAY, DECAY_EPOCH=(30, 50, 70)): # Hyper Parameter DECAY_EPOCH = [int(x) for x in DECAY_EPOCH] # mission_id = 1 mission_kind = dict_mission[mission_id] log_dir = '/media/tang/code/tianchi/logs/' + mission_kind model_dir = '/media/tang/code/tianchi/models/' + mission_kind if not os.path.exists(log_dir): os.makedirs(log_dir) if not os.path.exists(model_dir): os.makedirs(model_dir) split_percent = 0.1 IMAGE_CLASS = label_count[mission_kind] log_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) log_txt = mission_kind + ' googlenet {} BZ_{} EPO_{} LR_{} LR_DE_{} DE_EPO_{}'. \ format(log_time, BATCH_SIZE, EPOCH, LR, LR_DECAY, DECAY_EPOCH) log_path = os.path.join(log_dir, log_txt) log_txt = open(log_path, 'wb') normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) train_transform = transforms.Compose([ transforms.RandomRotation(5, resample=False, expand=False, center=None), # transforms.RandomResizedCrop(224, scale=(0.8, 1.0), ratio=(4./3., 3./4.)), # transforms.ColorJitter(brightness=0.05, contrast=0.05, saturation=0.05, hue=0.05), transforms.RandomCrop(299), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize, ]) val_transform = transforms.Compose([ # transforms.CenterCrop(224), # transforms.TenCrop() transforms.ToTensor(), normalize, ]) all_data_list = load_train_label()[mission_kind] np.random.shuffle(all_data_list) train_data_list, val_data_list = split_data(all_data_list, split_percent) train_data = MyDataset(label_list=train_data_list, transform=train_transform, loader=default_loader) val_data = MyDataset(label_list=val_data_list, transform=val_transform, loader=valdata_loader) train_loader = Data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True, num_workers=1) val_loader = Data.DataLoader(dataset=val_data, batch_size=BATCH_SIZE, num_workers=1) dataset_sizes = {'train': len(train_data), 'val': len(val_data)} print '*********** train: ', mission_id, ':', mission_kind, '*************' print mission_kind + ': train pics::', dataset_sizes[ 'train'], 'val pics:', dataset_sizes['val'] model = pretrainedmodels.inceptionresnetv2(pretrained='imagenet') print model # model = models.inception_v3(pretrained=True) # model.fc = nn.Linear(2048, IMAGE_CLASS) # model.AuxLogits.fc = nn.Linear(768, IMAGE_CLASS) # model = models.resnet50(pretrained=True) # model.fc = nn.Linear(2048, IMAGE_CLASS) # model = torch.load('/media/tang/code/data/models/mixup_models/mixup_cub_googlenet_159_0.7948.pkl') # print model # for i, param in enumerate(model.parameters()): # param.requires_grad = True # print # multi gpu # model = DataParallel(model) model.cuda() # Optimize only the classifier optimizer = torch.optim.SGD(model.parameters(), lr=LR, momentum=0.9) scheduler = lr_scheduler.MultiStepLR(optimizer, milestones=DECAY_EPOCH, gamma=LR_DECAY) loss_func = torch.nn.CrossEntropyLoss() TOP_ACC = 0.70 for epoch in range(1, EPOCH + 1): scheduler.step() lr = scheduler.get_lr() # train # lr = LR * (LR_DECAY ** (epoch // DECAY_EPOCH)) # for param_group in optimizer.param_groups: # param_group['lr'] = lr info = 'Epoch:{}/{} Lr={:.4f} | '.format(epoch, EPOCH, float(lr[0])) model.train() time_s = time.time() running_loss = 0 running_corrects = 0 for step, (x, y) in enumerate(train_loader): x, y = Variable(x).cuda(), Variable(y).cuda() out1, out2 = model(x) loss = loss_func(out1, y) + loss_func(out2, y) optimizer.zero_grad() loss.backward() optimizer.step() _, preds = torch.max(out1.data + out2.data, 1) running_loss += loss.data[0] * x.size(0) running_corrects += torch.sum(preds == y.data) use_time = time.time() - time_s train_speed = dataset_sizes['train'] // use_time epoch_loss = running_loss / dataset_sizes['train'] epoch_acc = 1.0 * running_corrects / dataset_sizes['train'] info += '{} Loss:{:.4f} Acc:{:.4f} '.format('train', epoch_loss, epoch_acc) info += '[{:.1f}mins/{}pics] | '.format(use_time / 60.0, train_speed) # val valset model.eval() time_s = time.time() running_loss = 0 running_corrects = 0 for step, (x, y) in enumerate(val_loader): # x.ivolatile = True x, y = Variable(x).cuda(), Variable(y).cuda() out = model(x) loss = loss_func(out, y) _, preds = torch.max(out.data, 1) running_loss += loss.data[0] * x.size(0) running_corrects += torch.sum(preds == y.data) use_time = time.time() - time_s train_speed = dataset_sizes['val'] // use_time epoch_loss = running_loss / dataset_sizes['val'] epoch_acc = 1.0 * running_corrects / dataset_sizes['val'] info += '{} Loss:{:.4f} Acc:{:.4f} '.format('val', epoch_loss, epoch_acc) info += '[{:.1f}mins/{}pics]'.format(use_time / 60.0, train_speed) print info log_txt.write(info + '\n') if TOP_ACC < epoch_acc: TOP_ACC = epoch_acc model_sava_path = os.path.join( model_dir, mission_kind + '_googlenet_%s_%.4f.pkl' % (epoch, epoch_acc)) torch.save(model, model_sava_path) torch.save(model, os.path.join(model_dir, 'best_model.pkl')) acc_info = 'save epoch:{} acc:{}'.format(epoch, epoch_acc) print acc_info log_txt.write(acc_info + '\n') log_txt.close()