def load_model(self, pretrained=False): if pretrained: model = models.deeplabv3_resnet101(pretrained=True) else: model = models.deeplabv3_resnet101() model.to(self.device) model.eval() return model
def setUp(self) -> None: super().setUp() self._model = Model(arch=deeplabv3_resnet101(pretrained=True)) self._model_ema = EMA_Model(Model(deeplabv3_resnet101(False)), alpha=0.9, weight_decay=1e-4) # self._model_ema._model.load_state_dict(self._model.state_dict()) self._device = torch.device( "cuda" if torch.cuda.is_available() else "cpu") self._img = (ToTensor()( Image.open("img1.jpg").convert("RGB")).unsqueeze(0).to( self._device)) self._model.to(self._device) self._model_ema.to(self._device)
def main(): print('Loading training and validation set images...') # Getting training and validation data dataloaders = get_dataloaders(random_transform=True, random_rotate=True, random_hflip=True, random_vflip=True, train_ratio=0.8) print('Starting training of model...') # # The way the winning submission was trained, takes about ~3 hours with GPU # model = deeplabv3_resnet101(num_classes=1, pretrained=False) # model, epoch_stats, model_path, best_f1 = train_model( # model, dataloaders, num_epochs=5, learning_rate=0.0002, deeplab=True) print('Loading best model and writing predictions for test set...') # Getting the best model from training and using it on test set empty_model = deeplabv3_resnet101(num_classes=1, pretrained=False) model_path = 'trained_models/20191209-020809-net.pth' # submission: 31396 write_predictions(empty_model, model_path, deeplab=True, patched=False, image_path='predictions') print('Creating csv submission from prediction images...') # Creating csv create_submission() print('Done.')
def test_deeplab(self): x = Variable(torch.randn(BATCH_SIZE, 3, 224, 224).fill_(1.0)) self.exportTest(toC( deeplabv3_resnet101(pretrained=False, pretrained_backbone=False)), toC(x), rtol=1e-3, atol=1e-5)
def discriminator(model='MobileNet', n_classes=3): default_scope = True device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print("Device: %s" % device) model_dict = {} if model == 'DeepLab': model_dict[model] = deeplabv3_resnet101(pretrained=True, progress=True, num_classes=21, aux_loss=None) if default_scope: grad_check(model_dict[model]) else: grad_check(model_dict[model], model_layers='All') model_dict[model].classifier[-1] = torch.nn.Conv2d( 256, n_classes, kernel_size=(1, 1), stride=(1, 1)).requires_grad_() model_dict[model].aux_classifier[-1] = torch.nn.Conv2d( 256, n_classes, kernel_size=(1, 1), stride=(1, 1)).requires_grad_() if model == "MobileNet": model_dict[model] = _segm_mobilenet('deeplabv3', 'mobile_net', output_stride=8, num_classes=n_classes, pretrained_backbone=True) grad_check(model_dict[model], model_layers='All') # Setup visualization for model_name, model in model_dict.items(): print(model_name) return model_dict
def __init__(self): super(Encoder101, self).__init__() self.resnet = deeplabv3_resnet101(pretrained=True) self.conv1_p = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=True) resnet = fcn_resnet101(pretrained=True) self.conv1 = resnet.backbone.conv1 self.bn1 = resnet.backbone.bn1 self.relu = resnet.backbone.relu # 1/2, 64 self.maxpool = resnet.backbone.maxpool self.res2 = resnet.backbone.layer1 # 1/4, 256 self.res3 = resnet.backbone.layer2 # 1/8, 512 self.res4 = resnet.backbone.layer3 # 1/16, 1024 self.res5 = resnet.backbone.layer4 # 1/32, 2048 self.register_buffer( 'mean', torch.FloatTensor([0.485, 0.456, 0.406]).view(1, 3, 1, 1)) self.register_buffer( 'std', torch.FloatTensor([0.229, 0.224, 0.225]).view(1, 3, 1, 1))
def load_seg_model(cfg, load_model_only=False): modeltype = cfg['training']['model'] if modeltype == 'fcn_resnet101': n_channels = len(cfg['data']['input_classes']) n_outputs = len(cfg['data']['output_classes']) model = fcn_resnet101(pretrained=False, num_classes=n_outputs) model.backbone.conv1 = nn.Conv2d(n_channels, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False) elif modeltype == 'deeplabv3_resnet101': n_channels = len(cfg['data']['input_classes']) n_outputs = len(cfg['data']['output_classes']) aux_loss = cfg['training']['aux_loss'] is not False model = deeplabv3_resnet101(pretrained=False, num_classes=n_outputs, aux_loss=aux_loss) model.backbone.conv1 = nn.Conv2d(n_channels, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False) elif modeltype == 'higher_hrnet': hrnet_cfg = get_hrnet_cfg(cfg) model = get_hrnet_model(hrnet_cfg) else: raise ValueError() if modelpath := cfg['resume'].get('path', None): state = torch.load(modelpath) model.load_state_dict(state['state_dict']) if load_model_only: return model starting_epoch = state['epoch'] if conf_epoch := cfg['resume'].get('epoch', None): print( f"WARNING: Loaded model trained for {starting_epoch - 1} epochs but config explicitly overrides to {conf_epoch}") starting_epoch = conf_epoch
def __init__( self, segmenter: nn.Module = segmentation.deeplabv3_resnet101( pretrained=True), keypoint_estimator: nn.Module = detection.keypointrcnn_resnet50_fpn( pretrained=True), input_height: int = 600, ): self.segmenter = segmenter self.keypoint_estimator = keypoint_estimator self.input_height = input_height self.cache = {} self.cache["keypoints"] = {} self.cache["masks"] = {} self.cache["images"] = {} # Move to GPUs if available # BodyPoseEstimator handles this for itself self.device = torch.device( "cuda" if torch.cuda.is_available() else "cpu") if self.segmenter: segmenter.to(self.device) self.segmenter.eval() if self.keypoint_estimator: keypoint_estimator.to(self.device) self.keypoint_estimator.eval()
def get_model(model_name: str, device, num_classes: int, pretrained: bool = False) -> torch.nn: """ Gets the model requested from the config file :param model_name: name of model used in the program :param device: name of device model is hosted on :param num_classes: number of classes in the model (including background 0,0,0) :param pretrained: boolean of starting on a pretrained model :return: the nn.model to be trained """ print(pretrained) model_dict = {'fcn_resnet50': models.fcn_resnet50(pretrained=pretrained, num_classes=num_classes).to(device).eval(), 'fcn_resnet101': models.fcn_resnet101(pretrained=pretrained, num_classes=num_classes).to(device).eval(), 'deeplabv3_resnet50': models.deeplabv3_resnet50(pretrained=pretrained, num_classes=num_classes).to(device).eval(), 'deeplabv3_resnet101': models.deeplabv3_resnet101(pretrained=pretrained, num_classes=num_classes).to(device).eval(), 'deeplabv3_mobilenet_v3_large': models.deeplabv3_mobilenet_v3_large(pretrained=pretrained, num_classes=num_classes).to( device).eval(), 'lraspp_mobilenet_v3_large': models.lraspp_mobilenet_v3_large(pretrained=pretrained, num_classes=num_classes).to( device).eval() } try: model = model_dict[model_name] except KeyError: print(f"KeyError, model_name is not valid allowable names are: {model_dict.keys()}") model = None model = model.eval() return model
def __init__(self): super(DeepLab, self).__init__() # define model self.model = deeplabv3_resnet101(num_classes=7, progress=True) self.model.classifier[4] = nn.Conv2d(in_channels=256, out_channels=8, kernel_size=1, stride=1)
def loadModel(): global model # model = torch.hub.load('pytorch/vision:v0.5.0', 'deeplabv3_resnet101', # num_classes=NUM_LABELS, pretrained=False, progress=True) model = deeplabv3_resnet101(num_classes=NUM_LABELS) model.train() print(model) return model
def tv_deeplab(arch, **kwargs): if arch == "resnet50": return tv_segm.deeplabv3_resnet50(pretrained=False, progress=False, num_classes=1) elif arch == "resnet101": return tv_segm.deeplabv3_resnet101(pretrained=True, progress=False, num_classes=1)
def load_model(): global model if opt.model == 50: model = deeplabv3_resnet50(num_classes=NUM_LABELS, pretrained=False) elif opt.model == 101: model = deeplabv3_resnet101(num_classes=NUM_LABELS, pretrained=False) else: raise Exception(f'Invalid model: {opt.model}') model = model.to(device)
def __init__(self, num_classes, pretrained=True): super(DeepLabv3ResNet101Wrapper, self).__init__() self.deeplab = deeplabv3_resnet101(pretrained=False, num_classes=num_classes) if pretrained: state_dict = model_zoo.load_url(self.URL) final_keys = [k for k in state_dict.keys() if k.startswith('classifier.4')] for k in final_keys: del state_dict[k] self.deeplab.load_state_dict(state_dict, strict=False)
def get_network(params): if params.architecture == 'deeplab_resnet101': net = deeplabv3_resnet101(pretrained=params.pretrained) if params.architecture == 'deeplab_resnet50': net = deeplabv3_resnet50(pretrained=params.pretrained) if 'activation' in params.dict: net.classifier[-1] = nn.Sequential(nn.Conv2d(256, params.num_classes, 1, 1 ), get_activation_func(params.activation)) else: net.classifier[-1] = nn.Conv2d(256, params.num_classes, 1, 1 ) return net
def __init__(self, in_channels=256, out_channels=1): super(SPM, self).__init__() self.ResNet = deeplabv3_resnet101(pretrained=True) self.ResNet.classifier[4] = nn.Conv2d(in_channels, out_channels, kernel_size=(1, 1), stride=(1, 1)) self.ResNet.aux_classifier[4] = nn.Conv2d(in_channels, out_channels, kernel_size=(1, 1), stride=(1, 1))
def resnet101_deeplabv3_coco(num_classes=21, pretrained=True): if deeplabv3_resnet101 is None: raise NotImplementedError( 'DeepLab v3 not available on this installation; requires PyTorch 1.1 and ' 'torchvision 0.3') deeplab = deeplabv3_resnet101(pretrained=False, num_classes=num_classes) if pretrained: url_coco = 'https://download.pytorch.org/models/deeplabv3_resnet101_coco-586e9e4e.pth' state_dict = model_zoo.load_url(url_coco) deeplab2._load_state_into_model(deeplab, state_dict) return deeplab3plus.DeepLabv3Wrapper(deeplab)
def load_model(device, model_type, model_path, n): if model_type == 50: model = deeplabv3_resnet50(num_classes=NUM_LABELS, pretrained=False) elif model_type == 101: model = deeplabv3_resnet101(num_classes=NUM_LABELS, pretrained=False) else: raise Exception(f'Invalid model: {model_type}') model = model.to(device) model.load_state_dict( torch.load(os.path.join(model_path, f'model_{n}.pth'))) model.eval() return model
def __init__(self, use_cuda=True): self.device = torch.device( 'cuda' if torch.cuda.is_available() and use_cuda else 'cpu') self.model = deeplabv3_resnet101(pretrained=True) self.model.to(self.device) self.transform = transforms.Compose([ ResizeCenterCrop(480), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ])
def test_VerboseModel(self): from torchvision.models.segmentation import deeplabv3_resnet101 verbose_resnet = VerboseModel(deeplabv3_resnet101(pretrained=True), submodels=[ 'backbone', 'classifier', ]) dummy_input = torch.ones(10, 3, 256, 256) _ = verbose_resnet(dummy_input) pass
def get_model(num_classes): # load an instance segmentation model pre-trained pre-trained on COCO model = deeplabv3_resnet101(pretrained=True) for param in model.parameters(): param.requires_grad = False deeplab_head_in_channels = model.classifier[0].convs[0][0].in_channels fcn_head_in_channels = model.classifier[1].in_channels model.classifier = DeepLabHead(deeplab_head_in_channels, num_classes) return model
def __init__(self, num_classes): super().__init__() self.num_classes = num_classes self.segm = deeplabv3_resnet101(pretrained=True) for param in self.segm.parameters(): param.requires_grad = False self.segm.classifier = DeepLabHead(in_channels=2048, num_classes=num_classes) self.segm.classifier.apply(_init_weights)
def __init__(self, n_channels=3, n_classes=21, softmax_out=True, resnet_type=101, pretrained=False): super(DeepLabv3, self).__init__() self.resnet_type = resnet_type self.n_channels = n_channels self.n_classes = n_classes self.pretrained = pretrained # Input conv is applied to convert the input to 3 ch depth self.inconv = None if n_channels != 3: self.inconv = FwdConv(n_channels, 3, kernel_size=1, padding=0) # Pre-trained model needs to be an identical network if pretrained: mid_classes = 21 else: mid_classes = n_classes # Maind body if resnet_type == 50: self.deeplab = deeplabv3_resnet50(pretrained=False, num_classes=mid_classes) self.pretrained = False else: self.deeplab = deeplabv3_resnet101(pretrained=pretrained, num_classes=mid_classes) if n_classes != 21: self.deeplab.classifier[-1] = nn.Conv2d(256, n_classes, kernel_size=(1, 1), stride=(1, 1)) if self.deeplab.aux_classifier != None: self.deeplab.aux_classifier[-1] = nn.Conv2d(256, n_classes, kernel_size=(1, 1), stride=(1, 1)) # Softmax alternative self.has_softmax = softmax_out if softmax_out: self.softmax = nn.Softmax2d() else: self.softmax = None
def resnet101_deeplabv3_imagenet(num_classes=21, pretrained=True): if deeplabv3_resnet101 is None: raise NotImplementedError( 'DeepLab v3 not available on this installation; requires PyTorch 1.1 and ' 'torchvision 0.3') deeplab = deeplabv3_resnet101(pretrained=False, num_classes=num_classes) if pretrained: # We can used the DeepLab2 ResNet-101 weights URL state_dict = model_zoo.load_url(deeplab2._RESNET_101_IMAGENET_URL) state_dict = { 'backbone.{}'.format(key): value for key, value in state_dict.items() } deeplab2._load_state_into_model(deeplab, state_dict) return deeplab3plus.DeepLabv3Wrapper(deeplab)
def __init__(self, end_module, keyword='out', pretrain=False, freeze=False): super(ResNet101_DeeplabV3, self).__init__() self.deeplab = models.deeplabv3_resnet101(pretrained=pretrain, progress=True, num_classes=21) if freeze: for module in self.deeplab.parameters(): module.requires_grad = False print("module frozen.") self.end_module = end_module self.output = None self.key = keyword
def __init__(self, num_classes=23): super(SegmentationNN, self).__init__() ####################################################################### # YOUR CODE # ####################################################################### self.num_classes = num_classes self.base = models.deeplabv3_resnet101(pretrained=True, progress=True) aux_classifier = list(self.base.aux_classifier.children()) self.base.aux_classifier = nn.Sequential(*aux_classifier[:-1]) self.base.aux_classifier.add_module('4', nn.Conv2d(256, num_classes, 1)) classifier = list(self.base.classifier.children()) self.base.classifier = nn.Sequential(*classifier[:-1]) self.base.classifier.add_module('4', nn.Conv2d(256, num_classes, 1))
def dextr_deeplab3(num_classes=1): model = segmentation.deeplabv3_resnet101(pretrained=True) # Create new input `conv1` layer that takes a 4-channel input new_conv1 = nn.Conv2d(4, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False) new_conv1.weight[:, :3, :, :] = model.backbone.conv1.weight model.backbone.conv1.weight.data = new_conv1.weight.data new_parameters = [] # Create new classifier output layer model.classifier[-1] = nn.Conv2d(256, num_classes, kernel_size=(1, 1), stride=(1, 1)) new_parameters.extend(list(model.classifier[-1].parameters())) if model.aux_classifier is not None: # Create new aux classifier output layer model.aux_classifier[-1] = nn.Conv2d(256, num_classes, kernel_size=(1, 1), stride=(1, 1)) new_parameters.extend(list(model.aux_classifier[-1].parameters())) # Setup new and pre-trained parameters for fine-tuning new_param_ids = {id(p) for p in new_parameters} pretrained_parameters = [ p for p in model.parameters() if id(p) not in new_param_ids ] model.pretrained_parameters = pretrained_parameters model.new_parameters = new_parameters return model
def __init__(self, num_classes: int = 2, ignore_index: Optional[int] = None, lr: float = 0.001, weight_decay: float = 0.001, aux_loss_factor: float = 0.3): super().__init__() self.num_classes = num_classes self.ignore_index = ignore_index self.lr = lr self.weight_decay = weight_decay self.aux_loss_factor = aux_loss_factor # Create model from pre-trained DeepLabv3 self.model = deeplabv3_resnet101(pretrained=True, progress=True) self.model.aux_classifier = FCNHead(1024, self.num_classes) self.model.classifier = DeepLabHead(2048, self.num_classes) # Setup trainable layers self.model.requires_grad_(True) self.model.backbone.requires_grad_(False) # Loss function and metrics self.focal_tversky_loss = FocalTverskyMetric( self.num_classes, alpha=0.7, beta=0.3, gamma=4.0 / 3.0, ignore_index=self.ignore_index, ) self.accuracy_metric = Accuracy(ignore_index=self.ignore_index) self.iou_metric = JaccardIndex( num_classes=self.num_classes, reduction="none", ignore_index=self.ignore_index, ) self.precision_metric = Precision(num_classes=self.num_classes, ignore_index=self.ignore_index, average='weighted', mdmc_average='global') self.recall_metric = Recall(num_classes=self.num_classes, ignore_index=self.ignore_index, average='weighted', mdmc_average='global')
limit_val_num_samples=100 if debug else None, random_seed=seed) prepare_batch = prepare_batch_fp32 # Image denormalization function to plot predictions with images img_denormalize = partial(denormalize, mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)) # ############################## # Setup models # ############################## num_classes = 21 model = deeplabv3_resnet101(num_classes=num_classes) def model_output_transform(output): return output['out'] # ############################## # Setup solver # ############################## num_epochs = 100 criterion = nn.CrossEntropyLoss() lr = 0.007
path_meta_data = r'samples/model_comparison.csv' save_path = r'/zhome/db/f/128823/Bachelor/model_predictions/3_classes/random' model_path = r'/work3/s173934/Bachelorprojekt/exp_results/resize_vs_randomcrop/3_class_dataset/randomcrop/DeepLab_ThreeClass_resize_false0.01.pt' else: path_original_data = r'C:\Users\Mads-_uop20qq\Documents\5. Semester\BachelorProj\leather_patches' path_train = r"C:\Users\Mads-_uop20qq\Documents\5. Semester\BachelorProj\Bachelorprojekt\tif_images" path_val = r"C:\Users\Mads-_uop20qq\Documents\5. Semester\BachelorProj\Bachelorprojekt\tif_images" path_meta_data = r'samples/model_comparison.csv' save_path = r'C:\Users\Mads-_uop20qq\Documents\5. Semester\BachelorProj\Bachelorprojekt\slet\predictions' model_path = r'E:\downloads_hpc_bachelor\exp_results\backbone\classifier_only\ResNet\DeepLab_backbone_exp0.01.pt' checkpoint = torch.load(model_path, map_location=device) if model_name == 'DeepLab': model = deeplabv3_resnet101(pretrained=True, progress=True, num_classes=21, aux_loss=None) model.classifier[-1] = torch.nn.Conv2d(256, n_classes + 2, kernel_size=(1, 1), stride=(1, 1)).requires_grad_() model.aux_classifier[-1] = torch.nn.Conv2d(256, n_classes + 2, kernel_size=(1, 1), stride=(1, 1)).requires_grad_() else: model = _segm_mobilenet('deeplabv3', 'mobile_net', output_stride=8, num_classes=n_classes + 2, pretrained_backbone=True)