def features(self) -> Tuple[nn.Module, nn.Module, int, int]: # Choose one [ResNeXt101_32x4d, ResNeXt101_64x4d] _pretrained = None if self._pretrained is True: _pretrained = "imagenet" resnext101 = pretrainedmodels.resnext101_64x4d(pretrained=_pretrained) children = list(resnext101.children()) features = children[:-2] num_features_out = 2048 hidden = children[-2] num_hidden_out = 2048 for parameters in [ feature.parameters() for i, feature in enumerate(features) if i <= 4 ]: for parameter in parameters: parameter.requires_grad = False features = nn.Sequential(*features) return features, hidden, num_features_out, num_hidden_out
def __init__(self, num_classes): super(ResNext, self).__init__() self.name = "ResNext" pretrained = model_zoo.resnext101_64x4d() cfg.mean = pretrained.mean cfg.std = pretrained.std self.features = pretrained.features self.fc = nn.Linear(2048, num_classes)
def __init__(self, num_classes=1, num_filters=32, pretrained=True, is_deconv=False): """ :param num_classes: :param num_filters: :param pretrained: False - no pre-trained network is used True - encoder is pre-trained with resnet34 :is_deconv: False: bilinear interpolation is used in decoder True: deconvolution is used in decoder """ super().__init__() self.num_classes = num_classes self.mean = (0.485, 0.456, 0.406) self.std = (0.229, 0.224, 0.225) self.pool = nn.MaxPool2d(2, 2) self.encoder = resnext101_64x4d() self.relu = nn.ReLU(inplace=True) self.conv1 = nn.Sequential(self.encoder.features[0], self.encoder.features[1], self.encoder.features[2], self.pool) self.conv2 = self.encoder.features[4] self.conv3 = self.encoder.features[5] self.conv4 = self.encoder.features[6] self.conv5 = self.encoder.features[7] self.center = DecoderBlockV2(2048, num_filters * 8 * 2, num_filters * 8, is_deconv) self.dec5 = DecoderBlockV2(2048 + num_filters * 8, num_filters * 8 * 2, num_filters * 8, is_deconv) self.dec4 = DecoderBlockV2(1024 + num_filters * 8, num_filters * 8 * 2, num_filters * 8, is_deconv) self.dec3 = DecoderBlockV2(512 + num_filters * 8, num_filters * 4 * 2, num_filters * 2, is_deconv) self.dec2 = DecoderBlockV2(256 + num_filters * 2, num_filters * 2 * 2, num_filters * 2 * 2, is_deconv) self.dec1 = DecoderBlockV2(num_filters * 2 * 2, num_filters * 2 * 2, num_filters, is_deconv) self.dec0 = ConvRelu(num_filters, num_filters) self.final = nn.Conv2d(num_filters, num_classes, kernel_size=1)
def __init__(self, feature_cascade=(512, 256, 64, 32), classes=262, training=None): super(ResNextColorizeClassifier, self).__init__() fc = feature_cascade self.upsample = nn.Upsample(scale_factor=2) fe = (1024, 512, 256, 64) resnet = pretrainedmodels.resnext101_64x4d(pretrained=None) resnet.features[0].weight = nn.Parameter( resnet.features[0].weight.sum(dim=1).unsqueeze(1).data) res_children = list(resnet.features.children()) self.ft1 = nn.Sequential(*res_children[0:3]) #64 filters, self.ft2 = nn.Sequential(*res_children[3:5]) # 256 filters self.ft3 = res_children[5] # 512 filters self.ft4 = res_children[6] # 1024 filters self.bn4 = nn.BatchNorm2d(fe[0]) self.conv4 = nn.Conv2d(fe[0], fc[0], kernel_size=3, stride=1, padding=1) sum3 = fc[0] + fe[1] self.bn3 = nn.BatchNorm2d(sum3) self.conv3 = nn.Conv2d(sum3, fc[1], kernel_size=3, stride=1, padding=1) sum2 = fc[1] + fe[2] self.bn2 = nn.BatchNorm2d(sum2) self.conv2 = nn.Conv2d(sum2, fc[2], kernel_size=3, stride=1, padding=1) sum1 = fc[2] + fe[3] self.bn1 = nn.BatchNorm2d(sum1) self.conv1 = nn.Conv2d(sum1, fc[3], kernel_size=3, stride=1, padding=1) self.bn0 = nn.BatchNorm2d(fc[3]) self.conv0 = nn.Conv2d(fc[3], classes, kernel_size=3, stride=1, padding=1)
def resnext101_64x4d_(pretrained='imagenet', **kwargs): model = pretrainedmodels.resnext101_64x4d(pretrained=pretrained) model.avg_pool = nn.AvgPool2d((2, 5), stride=(2, 5)) model.last_linear = nn.Linear(512 * 4, 10) return model
def build_model(phase, num_classes=2): model = pm.resnext101_64x4d() base_model=list(model.children())[0] return S3FD(phase, base_model, multibox())
def __init__(self, pretrained="imagenet"): super(ResNext101_64x4d, self).__init__() self.model = pretrainedmodels.resnext101_64x4d(pretrained=pretrained) self.l0 = nn.Linear(2048, 1)
# In[15]: batch_size = 10 num_workers = 4 train_loader = DataLoader(train_dataset, batch_size=batch_size, num_workers=num_workers, pin_memory=True) test_loader = DataLoader(test_set, batch_size=batch_size, num_workers=num_workers, pin_memory=True) # In[16]: model = pretrainedmodels.resnext101_64x4d() # In[17]: model.avg_pool = nn.AvgPool2d((5,10)) # In[18]: model.last_linear = nn.Linear(model.last_linear.in_features, NUM_CLASSES) # In[19]:
def waveResnext101_64x4d(pretrained='imagenet', num_classes=41): base = pretrainedmodels.resnext101_64x4d(pretrained=pretrained) modules = list(base.children())[0] model = WaveResnext(modules, num_classes) return model
def Model_builder(configer): model_name = configer.model['name'] No_classes = configer.dataset_cfg["id_cfg"]["num_classes"] model_pretrained = configer.model['pretrained'] model_dataparallel = configer.model["DataParallel"] model_gpu_replica = configer.model["Multi_GPU_replica"] gpu_ids = configer.train_cfg["gpu"] if model_name == "Inceptionv3": model = PM.inceptionv3(num_classes=1000, pretrained=model_pretrained) d = model.last_linear.in_features model.last_linear = nn.Linear(d, No_classes) elif model_name == "Xception": model = PM.xception(num_classes=1000, pretrained=model_pretrained) d = model.last_linear.in_features model.last_linear = nn.Linear(d, No_classes) elif model_name == "VGG_19": model = PM.vgg19(num_classes=1000, pretrained=model_pretrained) d = model.last_linear.in_features model.last_linear = nn.Linear(d, No_classes) elif model_name == "Resnet18": model = PM.resnet18(num_classes=1000, pretrained=model_pretrained) d = model.last_linear.in_features model.last_linear = nn.Linear(d, No_classes) elif model_name == "Resnet50": model = PM.resnet50(num_classes=1000, pretrained=model_pretrained) d = model.last_linear.in_features model.last_linear = nn.Linear(d, No_classes) elif model_name == "Resnet101": model = PM.resnet101(num_classes=1000, pretrained=model_pretrained) d = model.last_linear.in_features model.last_linear = nn.Linear(d, No_classes) elif model_name == "Resnet152": model = PM.resnet152(num_classes=1000, pretrained=model_pretrained) d = model.last_linear.in_features model.last_linear = nn.Linear(d, No_classes) elif model_name == "Resnet34": model = PM.resnet34(num_classes=1000, pretrained=model_pretrained) d = model.last_linear.in_features model.last_linear = nn.Linear(d, No_classes) elif model_name == "Densenet121": model = PM.densenet121(num_classes=1000, pretrained=model_pretrained) d = model.last_linear.in_features model.last_linear = nn.Linear(d, No_classes) elif model_name == "ResNeXt101-32": model = PM.resnext101_32x4d(num_classes=1000, pretrained=model_pretrained) d = model.last_linear.in_features model.last_linear = nn.Linear(d, No_classes) elif model_name == "ResNeXt101-64": model = PM.resnext101_64x4d(num_classes=1000, pretrained=model_pretrained) d = model.last_linear.in_features model.last_linear = nn.Linear(d, No_classes) elif model_name == "MobilenetV2": model = MobileNetV2(n_class=No_classes) else: raise ImportError("Model Architecture not supported") # Performing Data Parallelism if configured if model_dataparallel: model = torch.nn.DataParallel(model.to(device), device_ids=gpu_ids) elif model_gpu_replica: torch.distributed.init_process_group(backend='nccl', world_size=1, rank=1) model = torch.nn.DistributedDataParallel(model.to(device), device_ids=gpu_ids) else: model = model.to(device) print('---------- Model Loaded') return model
train_sampler = SubsetRandomSampler(list(range(len(os.listdir('train'))))) valid_sampler = SubsetRandomSampler(list(range(len(os.listdir('test'))))) batch_size = 10 num_workers = 2 # prepare data loaders (combine dataset and sampler) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, sampler=train_sampler, num_workers=num_workers) test_loader = torch.utils.data.DataLoader(test_set, batch_size=10, num_workers=num_workers) # get pretrained resnet model_conv = pretrainedmodels.resnext101_64x4d() for param in model_conv.parameters(): param.requires_grad = False model_conv.avg_pool = nn.AvgPool2d((5, 10)) model_conv.last_linear = nn.Linear(model_conv.last_linear.in_features, 5005) criterion = nn.BCEWithLogitsLoss() optimizer = optim.Adam(model_conv.parameters(), lr=0.01) exp_lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=3, gamma=0.1) n_epochs = 20 for epoch in range(1, n_epochs + 1): print(time.ctime(), 'Epoch:', epoch) train_loss = []
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 resnext(groups, width_per_group): if groups == 64 and width_per_group == 4: return pretrainedmodels.resnext101_64x4d()