def __init__(self, class_num ): super().__init__() model_ft = models.densenet121(pretrained=True) model_ft.features.avgpool = nn.AdaptiveAvgPool2d((1,1)) model_ft.fc = nn.Sequential() self.model = model_ft # For DenseNet, the feature dim is 1024 self.classifier = ClassBlock(1024, class_num)
def densenet121(num_classes=1000, pretrained='imagenet'): r"""Densenet-121 model from `"Densely Connected Convolutional Networks" <https://arxiv.org/pdf/1608.06993.pdf>` """ model = models.densenet121(pretrained=False) if pretrained is not None: settings = pretrained_settings['densenet121'][pretrained] model = load_pretrained(model, num_classes, settings) return model
def select_model(name='vgg19'): if name == 'vgg19': model, feature_count = models.vgg19_bn(pretrained=True), 25088 elif name == 'densenet161': model, feature_count = models.densenet161(pretrained=True), 2208 elif name == 'densenet121': model, feature_count = models.densenet121(pretrained=True), 1024 else: model, feature_count = models.alexnet(pretrained=True), 9216 return model, feature_count
def get_model(num_classes, model_type='resnet50'): if model_type == 'resnet50': model = resnet50(pretrained=True).cuda() model.fc = nn.Linear(model.fc.in_features, num_classes).cuda() elif model_type == 'resnet101': model = resnet101(pretrained=True).cuda() model.fc = nn.Linear(model.fc.in_features, num_classes).cuda() elif model_type == 'resnet152': model = resnet152(pretrained=True).cuda() model.fc = nn.Linear(model.fc.in_features, num_classes).cuda() elif model_type == 'densenet121': model = densenet121(pretrained=True).cuda() model.classifier = nn.Linear(model.classifier.in_features, num_classes).cuda() elif model_type == 'densenet161': model = densenet161(pretrained=True).cuda() model.classifier = nn.Linear(model.classifier.in_features, num_classes).cuda() elif model_type == 'densenet201': model = densenet201(pretrained=True).cuda() model.classifier = nn.Linear(model.classifier.in_features, num_classes).cuda() return model
def load_arch(arch): """ Load a pretrained network """ if arch == 'vgg16': model = models.vgg16(pretrained=True) input_size = 25088 elif arch == 'alexnet': model = models.alexnet(pretrained=True) input_size = 9216 elif arch == 'resnet18': model = models.resnet18(pretrained=True) input_size = 512 elif arch == 'densenet121': model = models.densenet121(pretrained=True) input_size = 1024 else: raise ValueError('Please choose one of \'vgg16\', \'alexnet\', \'resnet18\' or , \'densenet121\' for parameter arch.') for param in model.parameters(): param.requires_grad = False return model, input_size
from flask import Flask, render_template, request, redirect, url_for from get_images import get_images, get_path, get_directory from get_prediction import get_prediction from generate_html import generate_html from torchvision import models import json app = Flask(__name__) # mapping imagenet_class_mapping = json.load(open('imagenet_class_index.json')) # Make sure to pass `pretrained` as `True` to use the pretrained weights: model = models.densenet121(pretrained=True) # Since we are using our model only for inference, switch to `eval` mode: model.eval() def get_image_class(path): get_images(path) path = get_path(path) images_with_tags = get_prediction(model, imagenet_class_mapping, path) print(images_with_tags) generate_html(images_with_tags) @app.route('/') def home(): return render_template('home.html') @app.route('/', methods=['POST', 'GET'])
def initialize_model(model_name, num_classes, feature_extract, use_pretrained=True): # Initialize these variables which will be set in this if statement. Each of these # variables is model specific. model_ft = None input_size = 0 if model_name == "resnet": """ resnet34 """ model_ft = models.resnet34(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.fc.in_features model_ft.fc = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "alexnet": """ Alexnet """ model_ft = models.alexnet(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.classifier[6].in_features model_ft.classifier[6] = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "vgg": """ VGG16_bn """ model_ft = models.vgg16_bn(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.classifier[6].in_features model_ft.classifier[6] = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "squeezenet": """ Squeezenet """ model_ft = models.squeezenet1_0(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) model_ft.classifier[1] = nn.Conv2d(512, num_classes, kernel_size=(1, 1), stride=(1, 1)) model_ft.num_classes = num_classes input_size = 224 elif model_name == "densenet": """ Densenet """ model_ft = models.densenet121(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.classifier.in_features model_ft.classifier = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "inception": """ Inception v3 Be careful, expects (299,299) sized images and has auxiliary output """ model_ft = models.inception_v3(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) # Handle the auxilary net num_ftrs = model_ft.AuxLogits.fc.in_features model_ft.AuxLogits.fc = nn.Linear(num_ftrs, num_classes) # Handle the primary net num_ftrs = model_ft.fc.in_features model_ft.fc = nn.Linear(num_ftrs, num_classes) input_size = 299 else: print("Invalid model name, exiting...") exit() return model_ft, input_size
def __init__(self, num_classes): super(DenseModel, self).__init__() self.densenet = densenet121(pretrained=False) self.input_dense = nn.Linear(300, 3 * 32 * 32) self.output_f = nn.Linear(1024, 300) self.classifier = nn.Linear(300, num_classes)
def create_model(structure='densenet121', dropout=0.3, lr=0.003, hidden_units=512, checkpoint=None): global model global criterion criterion = nn.NLLLoss() global optimizer if checkpoint is None: output_size = 102 if structure == 'densenet121': model = models.densenet121(pretrained=True) input_size = 1024 elif structure == 'vgg16': model = models.vgg16(pretrained=True) input_size = 25088 elif structure == 'vgg13': model = models.vgg13(pretrained=True) input_size = 4096 if not model.classifier is None: if type(model.classifier) is nn.Linear: input_size = model.classifier.in_features else: input_size = model.classifier[0].in_features print(f"Input size: {input_size}") print("Created model.") for param in model.parameters(): param.requires_grad = False model.classifier = nn.Sequential( OrderedDict([('fc1', nn.Linear(input_size, hidden_units)), ('relu1', nn.ReLU()), ('dropout1', nn.Dropout(p=dropout)), ('fc2', nn.Linear(hidden_units, output_size)), ('output', nn.LogSoftmax(dim=1))])) optimizer = optim.Adam(model.parameters(), lr) else: structure = checkpoint['structure'] epochs = checkpoint['epochs'] dropout = checkpoint['dropout'] if structure == 'densenet121': model = models.densenet121(pretrained=True) input_size = 1024 elif structure == 'vgg16': model = models.vgg16(pretrained=True) input_size = 25088 elif structure == 'vgg13': model = models.vgg13(pretrained=True) input_size = 4096 model.classifier = checkpoint['classifier'] model.class_to_idx = checkpoint['class_to_idx'] model.load_state_dict(checkpoint['state_dict']) optimizer = optim.Adam(model.parameters(), checkpoint['learning_rate']) optimizer.load_state_dict(checkpoint['optim_state_dict']) print("Loaded checkpoint") print("Configured model.") #print(device) model.to(device)
def __init__(self, name, config): """ Initializes the ``LeNet5`` model, creates the required layers. :param name: Name of the model (taken from the configuration file). :param config: Parameters read from configuration file. :type config: ``ptp.configuration.ConfigInterface`` """ super(GenericImageEncoder, self).__init__(name, GenericImageEncoder, config) # Get key mappings. self.key_inputs = self.stream_keys["inputs"] self.key_outputs = self.stream_keys["outputs"] # Get operation modes. self.return_feature_maps = self.config["return_feature_maps"] pretrained = self.config["pretrained"] # Get model type from configuration. self.model_type = get_value_from_dictionary( "model_type", self.config, "vgg16 | densenet121 | resnet152 | resnet50".split(" | ")) if (self.model_type == 'vgg16'): # Get VGG16 self.model = models.vgg16(pretrained=pretrained) if self.return_feature_maps: # Use only the "feature encoder". self.model = self.model.features # Height of the returned features tensor (SET) self.feature_maps_height = 7 self.globals["feature_maps_height"] = self.feature_maps_height # Width of the returned features tensor (SET) self.feature_maps_width = 7 self.globals["feature_maps_width"] = self.feature_maps_width # Depth of the returned features tensor (SET) self.feature_maps_depth = 512 self.globals["feature_maps_depth"] = self.feature_maps_depth else: # Use the whole model, but cut/reshape only the last layer. self.output_size = self.globals["output_size"] # "Replace" the last layer. self.model.classifier._modules['6'] = torch.nn.Linear( 4096, self.output_size) elif (self.model_type == 'densenet121'): # Get densenet121 self.model = models.densenet121(pretrained=pretrained) if self.return_feature_maps: raise ConfigurationError( "'densenet121' doesn't support 'return_feature_maps' mode (yet)" ) # Use the whole model, but cut/reshape only the last layer. self.output_size = self.globals["output_size"] self.model.classifier = torch.nn.Linear(1024, self.output_size) elif (self.model_type == 'resnet152'): # Get resnet152 self.model = models.resnet152(pretrained=pretrained) if self.return_feature_maps: # Get all modules exluding last (avgpool) and (fc) modules = list(self.model.children())[:-2] self.model = torch.nn.Sequential(*modules) # Height of the returned features tensor (SET) self.feature_maps_height = 7 self.globals["feature_maps_height"] = self.feature_maps_height # Width of the returned features tensor (SET) self.feature_maps_width = 7 self.globals["feature_maps_width"] = self.feature_maps_width # Depth of the returned features tensor (SET) self.feature_maps_depth = 2048 self.globals["feature_maps_depth"] = self.feature_maps_depth else: # Use the whole model, but cut/reshape only the last layer. self.output_size = self.globals["output_size"] self.model.fc = torch.nn.Linear(2048, self.output_size) elif (self.model_type == 'resnet50'): # Get resnet50 self.model = models.resnet50(pretrained=pretrained) if self.return_feature_maps: # Get all modules exluding last (avgpool) and (fc) modules = list(self.model.children())[:-2] self.model = torch.nn.Sequential(*modules) # Height of the returned features tensor (SET) self.feature_maps_height = 7 self.globals["feature_maps_height"] = self.feature_maps_height # Width of the returned features tensor (SET) self.feature_maps_width = 7 self.globals["feature_maps_width"] = self.feature_maps_width # Depth of the returned features tensor (SET) self.feature_maps_depth = 2048 self.globals["feature_maps_depth"] = self.feature_maps_depth else: # Use the whole model, but cut/reshape only the last layer. self.output_size = self.globals["output_size"] self.model.fc = torch.nn.Linear(2048, self.output_size)
def setup_model(self, distributed): if (self.modelname == "resnet"): pretrained_model = ResNet101(BatchNorm=nn.BatchNorm2d, pretrained=True, output_stride=16) resnet_bottom = torch.nn.Sequential( *list(pretrained_model.children()) [:-1]) # remove last layer (fc) layer model = RN101_newtop(base_model=resnet_bottom, num_classes=self.N_CLASSES) elif (self.modelname == 'densenet'): model = models.densenet121(pretrained=True) num_ftrs = model.classifier.in_features model.classifier = nn.Linear(num_ftrs, self.N_CLASSES) elif (self.modelname == 'inception'): model = models.inception_v3(pretrained=True) #set_parameter_requires_grad(model_ft, feature_extract) # Handle the auxilary net num_ftrs = model.AuxLogits.fc.in_features model.AuxLogits.fc = nn.Linear(num_ftrs, self.N_CLASSES) # Handle the primary net num_ftrs = model.fc.in_features model.fc = nn.Linear(num_ftrs, self.N_CLASSES) elif (self.modelname == 'resnext'): self.batch_size_all = 4 # got cuda error model = models.resnext101_32x8d(pretrained=True) num_ftrs = model.fc.in_features model.fc = nn.Linear(num_ftrs, self.N_CLASSES) elif (self.modelname == 'pyramid'): model = prn.PyramidNet(dataset='imagenet', depth=101, alpha=360, num_classes=1000, bottleneck=True, pretrain=True) #input imagenet args num_ftrs = model.fc.in_features #model = torch.nn.Sequential(*list(pretrained_model.children())[:-1]) model.fc = nn.Linear(num_ftrs, self.N_CLASSES) elif (self.modelname == 'dpn'): model = torch.hub.load('rwightman/pytorch-dpn-pretrained', 'dpn92', pretrained=True) num_chs = model.classifier.in_channels #*self.batch_size_all model.classifier = nn.Conv2d(num_chs, self.N_CLASSES, kernel_size=1, bias=True) elif (self.modelname == 'aawide'): model = Wide_ResNet(depth=10, widen_factor=5, dropout_rate=0.3, num_classes=self.N_CLASSES, shape=32) self.lr_all = 1e-3 self.epochs_all = 100 elif (self.modelname == 'neat'): model = NeatCNN(num_classes=self.N_CLASSES, channel_size=256, group_size=2, depth=1, width=1, residual=False) self.epochs_all = 50 self.batch_size_all = 4 elif (self.modelname == 'neater'): model = NeatCNN(num_classes=self.N_CLASSES, channel_size=256, group_size=2, depth=3, width=1, residual=True) self.epochs_all = 50 self.batch_size_all = 4 print(model) model.cuda() if distributed: model = torch.nn.parallel.DistributedDataParallel(model) self.model = model
def initialize_model(model_name, num_classes, feature_extract, use_pretrained=True): # Initialize these variables which will be set in this if statement. Each of these # variables is model specific. model_ft = None input_size = 0 if model_name == "resnet": """ Resnet18 """ model_ft = models.resnet18(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.fc.in_features model_ft.fc = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "alexnet": """ Alexnet """ model_ft = models.alexnet(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.classifier[6].in_features model_ft.classifier[6] = nn.Linear(num_ftrs,num_classes) input_size = 224 elif model_name == "vgg": """ VGG11_bn """ model_ft = models.vgg11_bn(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.classifier[6].in_features model_ft.classifier[6] = nn.Linear(num_ftrs,num_classes) input_size = 224 elif model_name == "squeezenet": """ Squeezenet """ model_ft = models.squeezenet1_0(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) model_ft.classifier[1] = nn.Conv2d(512, num_classes, kernel_size=(1,1), stride=(1,1)) model_ft.num_classes = num_classes input_size = 224 elif model_name == "densenet": """ Densenet """ model_ft = models.densenet121(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.classifier.in_features model_ft.classifier = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "inception": """ Inception v3 Be careful, expects (299,299) sized images and has auxiliary output """ model_ft = models.inception_v3(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) # Handle the auxilary net num_ftrs = model_ft.AuxLogits.fc.in_features model_ft.AuxLogits.fc = nn.Linear(num_ftrs, num_classes) # Handle the primary net num_ftrs = model_ft.fc.in_features model_ft.fc = nn.Linear(num_ftrs,num_classes) input_size = 299 else: print("Invalid model name, exiting...") exit() return model_ft, input_size
def initialize_model(model_name, num_classes, freeze_layers, use_pretrained=True): # Initialize these variables which will be set in this if statement. Each of these # variables is model specific. model_ft = None if model_name == "resnet50": """ Resnet50 """ model_ft = models.resnet50(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, freeze_layers) num_ftrs = model_ft.fc.in_features model_ft.fc = nn.Linear(num_ftrs, num_classes) elif model_name == "resnet101": """ Resnet101 """ model_ft = models.resnet101(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, freeze_layers) num_ftrs = model_ft.fc.in_features model_ft.fc = nn.Linear(num_ftrs, num_classes) elif model_name == "resnet152": """ Resnet152 """ model_ft = models.resnet152(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, freeze_layers) num_ftrs = model_ft.fc.in_features model_ft.fc = nn.Linear(num_ftrs, num_classes) elif model_name == "alexnet": """ Alexnet """ model_ft = models.alexnet(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, freeze_layers) num_ftrs = model_ft.classifier[6].in_features model_ft.classifier[6] = nn.Linear(num_ftrs,num_classes) elif model_name == "vgg": """ VGG11_bn """ model_ft = models.vgg11_bn(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, freeze_layers) num_ftrs = model_ft.classifier[6].in_features model_ft.classifier[6] = nn.Linear(num_ftrs,num_classes) elif model_name == "squeezenet": """ Squeezenet """ model_ft = models.squeezenet1_0(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, freeze_layers) model_ft.classifier[1] = nn.Conv2d(512, num_classes, kernel_size=(1,1), stride=(1,1)) model_ft.num_classes = num_classes elif model_name == "densenet121": """ Densenet121 """ model_ft = models.densenet121(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, freeze_layers) num_ftrs = model_ft.classifier.in_features model_ft.classifier = nn.Linear(num_ftrs, num_classes) elif model_name == "densenet169": """ Densenet169 """ model_ft = init_densenet169() set_parameter_requires_grad(model_ft, freeze_layers) elif model_name == "densenet201": """ Densenet201 """ model_ft = models.densenet201(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, freeze_layers) num_ftrs = model_ft.classifier.in_features model_ft.classifier = nn.Linear(num_ftrs, num_classes) elif model_name == "inception": """ Inception v3 Be careful, expects (299,299) sized images and has auxiliary output """ model_ft = models.inception_v3(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, freeze_layers) # Handle the auxilary net num_ftrs = model_ft.AuxLogits.fc.in_features model_ft.AuxLogits.fc = nn.Linear(num_ftrs, num_classes) # Handle the primary net num_ftrs = model_ft.fc.in_features model_ft.fc = nn.Linear(num_ftrs,num_classes) elif model_name == "delf": """ DELF using our pretrained Densenet169 features """ model_ft = init_delf(num_classes) set_parameter_requires_grad(model_ft, 2) elif model_name == "delf_TL": """ DELF using our pretrained Densenet169 features, without FC layer """ model_ft = init_delf_TL() set_parameter_requires_grad(model_ft, 2) elif model_name == "our_densenet_TL": """ Our pretrained Densenet169 without FC layer """ model_ft = init_densenet_TL() set_parameter_requires_grad(model_ft, freeze_layers) elif model_name == "resnet101gem": model_ft = init_resnet101gem() set_parameter_requires_grad(model_ft, 0) elif model_name == "delf_pca": model_ft = init_delf_pca() set_parameter_requires_grad(model_ft, 1) else: print("Invalid model name, exiting...") exit() # model_ft = nn.Sequential(*list(model_ft.children())) return model_ft
def densenet121(args): return models.densenet121(pretrained=args.pretrained, num_classes=args.n_classes)
def __init__(self, num_dims): super().__init__() self.model = models.densenet121(pretrained=True) num_ftrs = self.model.classifier.in_features self.model.classifier = nn.Linear(num_ftrs, num_dims) print(summary(self.model, input_size=(32, 3, 100, 100)))
def get_backbone(name, pretrained=False): """ Loading backbone, defining names for skip-connections and encoder output. """ # TODO: More backbones # loading backbone model if name == 'resnet18': backbone = models.resnet18(pretrained=pretrained) elif name == 'resnet34': backbone = models.resnet34(pretrained=pretrained) elif name == 'resnet50': backbone = models.resnet50(pretrained=pretrained) elif name == 'resnet101': backbone = models.resnet101(pretrained=pretrained) elif name == 'resnet152': backbone = models.resnet152(pretrained=pretrained) elif name == 'vgg16': backbone = models.vgg16_bn(pretrained=pretrained).features elif name == 'vgg19': backbone = models.vgg19_bn(pretrained=pretrained).features # elif name == 'inception_v3': # backbone = models.inception_v3(pretrained=pretrained, aux_logits=False) elif name == 'densenet121': backbone = models.densenet121(pretrained=pretrained).features elif name == 'densenet161': backbone = models.densenet161(pretrained=pretrained).features elif name == 'densenet169': backbone = models.densenet169(pretrained=pretrained).features elif name == 'densenet201': backbone = models.densenet201(pretrained=pretrained).features elif name == 'unet_encoder': from unet_backbone import UnetEncoder backbone = UnetEncoder(3) else: raise NotImplemented( '{} backbone model is not implemented so far.'.format(name)) # specifying skip feature and output names if name.startswith('resnet'): feature_names = [None, 'relu', 'layer1', 'layer2', 'layer3'] backbone_output = 'layer4' elif name == 'vgg16': # TODO: consider using a 'bridge' for VGG models, there is just a MaxPool between last skip and backbone output feature_names = ['5', '12', '22', '32', '42'] backbone_output = '43' elif name == 'vgg19': feature_names = ['5', '12', '25', '38', '51'] backbone_output = '52' # elif name == 'inception_v3': # feature_names = [None, 'Mixed_5d', 'Mixed_6e'] # backbone_output = 'Mixed_7c' elif name.startswith('densenet'): feature_names = [ None, 'relu0', 'denseblock1', 'denseblock2', 'denseblock3' ] backbone_output = 'denseblock4' elif name == 'unet_encoder': feature_names = ['module1', 'module2', 'module3', 'module4'] backbone_output = 'module5' else: raise NotImplemented( '{} backbone model is not implemented so far.'.format(name)) return backbone, feature_names, backbone_output
def initialize_model(model_name, num_classes, feature_extract, use_pretrained=True): # Initialize these variables which will be set in this if statement. Each of these # variables is model specific. model_ft = None input_size = 0 if model_name == "resnet": """ Resnet18 Not very heavy on the gpu """ model_ft = models.resnet18(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.fc.in_features model_ft.fc = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "alexnet": """ Alexnet """ model_ft = models.alexnet(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.classifier[6].in_features model_ft.classifier[6] = nn.Linear(num_ftrs,num_classes) input_size = 224 elif model_name == "vgg": """ VGG11_bn """ model_ft = models.vgg11_bn(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.classifier[6].in_features model_ft.classifier[6] = nn.Linear(num_ftrs,num_classes) input_size = 224 elif model_name == "squeezenet": """ Squeezenet """ model_ft = models.squeezenet1_0(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) model_ft.classifier[1] = nn.Conv2d(512, num_classes, kernel_size=(1,1), stride=(1,1)) model_ft.num_classes = num_classes input_size = 224 elif model_name == "densenet": """ Densenet Used in the CheXpert paper """ model_ft = models.densenet121(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.classifier.in_features model_ft.classifier = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "efficient-densenet": """memory-efficient densenet - https://github.com/wandering007/efficient-densenet-pytorch 10-20% change in memory usage, about the same speed as original DenseNet """ # # growth_rate = 32 #(int) - how many filters to add each layer (`k` in paper) block_config = (6, 12, 24, 16) #(list of 3 or 4 ints) - how many layers in each pooling block compression = 0.5 #Reduction in size num_init_features = 2 * growth_rate #(int) - the number of filters to learn in the first convolution layer bn_size = 4 #(int) - mult. factor for number of bottle neck layers (i.e. bn_size * k features in the bottleneck layer) drop_rate = 0. #(float) - dropout rate after each dense layer efficient = True #(bool) - set to True to use checkpointing. Much more memory efficient, but slower. input_size = 224 model_ft = densenet.DenseNet(num_init_features=num_init_features, block_config=block_config, compression=compression, input_size=input_size, bn_size=bn_size, drop_rate=drop_rate, num_classes=1000, efficient=efficient) if use_pretrained: partial_state_dict = torch.load('src/models/densenet121_effi.pth') state_dict = model_ft.state_dict() state_dict.update(partial_state_dict) model_ft.load_state_dict(state_dict, strict=True) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.classifier.in_features model_ft.classifier = nn.Linear(num_ftrs, num_classes) elif model_name == "efficient-densenet-v2": """memory-efficient densenet, alternative version - https://github.com/gpleiss/efficient_densenet_pytorch Can load batches more than twice as large as original DenseNet, at less than half the speed """ # # growth_rate = 32 #(int) - how many filters to add each layer (`k` in paper) block_config = (6, 12, 24, 16) #(list of 3 or 4 ints) - how many layers in each pooling block compression = 0.5 #Reduction in size num_init_features = 2 * growth_rate #(int) - the number of filters to learn in the first convolution layer bn_size = 4 #(int) - mult. factor for number of bottle neck layers (i.e. bn_size * k features in the bottleneck layer) drop_rate = 0. #(float) - dropout rate after each dense layer efficient = True #(bool) - set to True to use checkpointing. Much more memory efficient, but slower. input_size = 224 # model_ft = densenet.DenseNet(num_init_features=num_init_features, block_config=block_config, compression=compression, # input_size=input_size, bn_size=bn_size, drop_rate=drop_rate, num_classes=1000, efficient=efficient) model_ft = dnet2.DenseNet(growth_rate=32, block_config=block_config, compression=0.5, num_init_features=num_init_features, bn_size=4, drop_rate=0, num_classes=1000, small_inputs=False, efficient=True) if use_pretrained: state_dict = model_ft.state_dict() partial_state_dict = torch.load('src/models/densenet121_effi.pth') partial_state_dict = {k: v for k, v in partial_state_dict.items() if k in state_dict} state_dict.update(partial_state_dict) model_ft.load_state_dict(state_dict, strict=True) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.classifier.in_features model_ft.classifier = nn.Linear(num_ftrs, num_classes) elif model_name == "inception": """ Inception v3 Be careful, expects (299,299) sized images and has auxiliary output """ model_ft = models.inception_v3(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) # Handle the auxilary net num_ftrs = model_ft.AuxLogits.fc.in_features model_ft.AuxLogits.fc = nn.Linear(num_ftrs, num_classes) # Handle the primary net num_ftrs = model_ft.fc.in_features model_ft.fc = nn.Linear(num_ftrs,num_classes) input_size = 299 else: print("Invalid model name, exiting...") exit() return model_ft, input_size
from torchvision import datasets, transforms, models import argparse ## set working directory and define data directories ## list of arguments parser = argparse.ArgumentParser() parser.add_argument('--data_dir', help = 'input the name of your dataset') #### list of models to use in this program model_dict = {'vgg16': models.vgg16(pretrained = True), 'vgg13': models.vgg13(pretrained = True), 'densenet121': models.densenet121(pretrained = True)} parser.add_argument('--arch', choices = model_dict.keys(), help = 'input your neural network architecture model from the dictionary displayed') parser.add_argument('--device', help = "Choose whether to work with a GPU or a CPU (input 'cuda' or 'cpu')") ## model hyperparameters parser.add_argument('--output_units', help = 'input number of output units', type = int) parser.add_argument('--learning_rate', help = 'input learning rate', type = float) parser.add_argument('--epochs', help = 'input number of output units', type = int) parser.add_argument('--save_dir', help = 'name of checkpoint directory')
def train_cnn(PATH_TO_IMAGES, LR, WEIGHT_DECAY, fine_tune=False, regression=False, freeze=False, adam=False, initial_model_path=None, initial_brixia_model_path=None, weighted_cross_entropy_batchwise=False, modification=None, weighted_cross_entropy=False): """ Train torchvision model to NIH data given high level hyperparameters. Args: PATH_TO_IMAGES: path to NIH images LR: learning rate WEIGHT_DECAY: weight decay parameter for SGD Returns: preds: torchvision model predictions on test fold with ground truth for comparison aucs: AUCs for each train,test tuple """ NUM_EPOCHS = 100 BATCH_SIZE = 32 try: rmtree('results/') except BaseException: pass # directory doesn't yet exist, no need to clear it os.makedirs("results/") # use imagenet mean,std for normalization mean = [0.485, 0.456, 0.406] std = [0.229, 0.224, 0.225] N_LABELS = 14 # we are predicting 14 labels N_COVID_LABELS = 3 # we are predicting 3 COVID labels # define torchvision transforms data_transforms = { 'train': transforms.Compose([ # transforms.RandomHorizontalFlip(), transforms.Resize(224), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean, std) ]), 'val': transforms.Compose([ transforms.Resize(224), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean, std) ]), } # create train/val dataloaders transformed_datasets = {} transformed_datasets['train'] = CXR.CXRDataset( path_to_images=PATH_TO_IMAGES, fold='train', transform=data_transforms['train'], fine_tune=fine_tune, regression=regression) transformed_datasets['val'] = CXR.CXRDataset( path_to_images=PATH_TO_IMAGES, fold='val', transform=data_transforms['val'], fine_tune=fine_tune, regression=regression) dataloaders = {} dataloaders['train'] = torch.utils.data.DataLoader( transformed_datasets['train'], batch_size=BATCH_SIZE, shuffle=True, num_workers=8) dataloaders['val'] = torch.utils.data.DataLoader( transformed_datasets['val'], batch_size=BATCH_SIZE, shuffle=True, num_workers=8) # please do not attempt to train without GPU as will take excessively long if not use_gpu: raise ValueError("Error, requires GPU") if initial_model_path or initial_brixia_model_path: if initial_model_path: saved_model = torch.load(initial_model_path) else: saved_model = torch.load(initial_brixia_model_path) model = saved_model['model'] del saved_model if fine_tune and not initial_brixia_model_path: num_ftrs = model.module.classifier.in_features if freeze: for feature in model.module.features: for param in feature.parameters(): param.requires_grad = False if feature == model.module.features.transition2: break if not regression: model.module.classifier = nn.Linear(num_ftrs, N_COVID_LABELS) else: model.module.classifier = nn.Sequential( nn.Linear(num_ftrs, 1), nn.ReLU(inplace=True)) else: model = models.densenet121(pretrained=True) num_ftrs = model.classifier.in_features model.classifier = nn.Linear(num_ftrs, N_LABELS) if modification == 'transition_layer': # num_ftrs = model.features.norm5.num_features up1 = torch.nn.Sequential( torch.nn.ConvTranspose2d(num_ftrs, num_ftrs, kernel_size=3, stride=2, padding=1), torch.nn.BatchNorm2d(num_ftrs), torch.nn.ReLU(True)) up2 = torch.nn.Sequential( torch.nn.ConvTranspose2d(num_ftrs, num_ftrs, kernel_size=3, stride=2, padding=1), torch.nn.BatchNorm2d(num_ftrs)) transition_layer = torch.nn.Sequential(up1, up2) model.features.add_module('transition_chestX', transition_layer) if modification == 'remove_last_block': model.features.denseblock4 = nn.Sequential() model.features.transition3 = nn.Sequential() # model.features.norm5 = nn.BatchNorm2d(512) # model.classifier = nn.Linear(512, N_LABELS) if modification == 'remove_last_two_block': model.features.denseblock4 = nn.Sequential() model.features.transition3 = nn.Sequential() model.features.transition2 = nn.Sequential() model.features.denseblock3 = nn.Sequential() model.features.norm5 = nn.BatchNorm2d(512) model.classifier = nn.Linear(512, N_LABELS) print(model) # put model on GPU if not initial_model_path: model = nn.DataParallel(model) model.to(device) if regression: criterion = nn.MSELoss() else: if weighted_cross_entropy: pos_weights = transformed_datasets[ 'train'].pos_neg_balance_weights() print(pos_weights) # pos_weights[pos_weights>40] = 40 criterion = nn.BCEWithLogitsLoss(pos_weight=pos_weights) else: criterion = nn.BCEWithLogitsLoss() if adam: optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=LR, weight_decay=WEIGHT_DECAY) else: optimizer = optim.SGD(filter(lambda p: p.requires_grad, model.parameters()), lr=LR, weight_decay=WEIGHT_DECAY, momentum=0.9) dataset_sizes = {x: len(transformed_datasets[x]) for x in ['train', 'val']} # train model if regression: model, best_epoch = train_model(model, criterion, optimizer, LR, num_epochs=NUM_EPOCHS, dataloaders=dataloaders, dataset_sizes=dataset_sizes, weight_decay=WEIGHT_DECAY, fine_tune=fine_tune, regression=regression) else: model, best_epoch = train_model( model, criterion, optimizer, LR, num_epochs=NUM_EPOCHS, dataloaders=dataloaders, dataset_sizes=dataset_sizes, weight_decay=WEIGHT_DECAY, weighted_cross_entropy_batchwise=weighted_cross_entropy_batchwise, fine_tune=fine_tune) # get preds and AUCs on test fold preds, aucs = E.make_pred_multilabel(dataloaders['val'], model, save_as_csv=False, fine_tune=fine_tune) return preds, aucs
def dn121(pre): return children(densenet121(pre))[0] def dn161(pre): return children(densenet161(pre))[0]
def self_train(method="", num_epochs=3, learning_rate=0.0001, batch_size=16, resize=320, rot_size=320, split=3, K=4, patch_size=64, grid_crop_size=225, patch_crop_size=64, perm_set_size=500, from_checkpoint=None, combo=[], root_PATH=root_PATH, root_PATH_dataset=root_PATH_dataset, saved_model_PATH=saved_model_PATH, show=False, batch_factor=False): model = models.densenet121() #optimizer =torch.optim.RMSprop(model.parameters(), lr=learning_rate) criterion = torch.nn.CrossEntropyLoss().to(device=device) plot_loss = {} #Setting permuation_set PATH_p_set = root_PATH + "SummerThesis/code/custom_lib/utilities/permutation_set/saved_permutation_sets/permutation_set" + str( perm_set_size) + ".pt" #just ToTensor before patch # transform_train= transforms.Compose([ transforms.Resize((resize,resize)), transforms.RandomHorizontalFlip(), transforms.ToTensor(),transforms.Normalize((0.5,), (0.5,)), # transforms.Lambda(lambda x: torch.cat([x, x, x], 0))]) transform_train = transforms.Compose([ transforms.Resize((resize, resize)), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Lambda(lambda x: torch.cat([x, x, x], 0)) ]) #after patch transformation #transform_after_patching= transforms.Compose([ transforms.Lambda(lambda x: torch.cat([x, x, x], 0))]) transform_after_patching = None #constant vars kwarg_Jigsaw = { "perm_set_size": perm_set_size, "path_permutation_set": PATH_p_set, "grid_crop_size": grid_crop_size, "patch_crop_size": patch_crop_size, "transform": transform_after_patching, "gpu": use_cuda, "show": show } kwarg_Relative_Position = { "patch_size": patch_size, "transform": transform_after_patching, "show": show, "labels_path": root_PATH } kwarg_Rotation = { "K": K, "resize": rot_size, "transform": transform_after_patching, "show": show } kwarg_Relative_Position_old = { "split": split, "transform": transform_after_patching, "show": show, "labels_path": root_PATH } kwarg_Common = { "num_epochs": num_epochs, "learning_rate": learning_rate, "batch_size": batch_size * batch_factor if batch_factor else batch_size } kwargs = { "Common": kwarg_Common, "Jigsaw": kwarg_Jigsaw, "Relative_Position": kwarg_Relative_Position, "Rotation": kwarg_Rotation, "Relative_Position_old": kwarg_Relative_Position_old } loader = load_model.Load_Model(method=method, combo=combo, from_checkpoint=from_checkpoint, kwargs=kwargs, model=model, plot_loss=plot_loss, use_cuda=use_cuda) file_name, head_arch, plot_loss = loader() n_heads = len(head_arch) saved_model_PATH = saved_model_PATH + "saved_models/self_supervised/" + file_name[: -4] if not os.path.exists(saved_model_PATH): os.mkdir(saved_model_PATH) labels_path = root_PATH + "SummerThesis/code/custom_lib/chexpert_load/labels.pt" cheXpert_train_dataset, dataloader = chexpert_load.chexpert_load( root_PATH + "SummerThesis/code/custom_lib/chexpert_load/train.csv", transform_train, batch_size, labels_path=labels_path, root_dir=root_PATH_dataset, num_workers=5) model = model.to(device=device) model.train() currentDT = datetime.datetime.now() print('START--', file_name) iter_count = np.zeros(n_heads) batch_count = -1 if batch_factor else 1 h_id = 0 for epoch in range(num_epochs): for i, (images, observations, _) in enumerate( dataloader ): # Load a batch of images with its (index, data, class) if batch_factor: if batch_count < (batch_factor - 1): batch_count += 1 elif batch_count == (batch_factor - 1): iter_count[h_id] += 1 batch_count = 0 h_id = (h_id + 1) % n_heads else: h_id = i % n_heads iter_count[h_id] += 1 head_dict = head_arch[h_id] model.classifier = head_dict["head"] patcher = head_dict["patch_func"](image_batch=images, **head_dict["args"]) optimizer = head_dict['optimizer'] patches, labels = patcher() patches = patches.to(device=device, dtype=torch.float32) labels = labels.to(device=device, dtype=torch.long) #break outputs = model( patches ) # Forward pass: compute the output class given a image loss = criterion( outputs, labels ) # Compute the loss: difference between the output class and the pre-given label if batch_factor and i % batch_factor == 0: optimizer.zero_grad( ) # Intialize the hidden weight to all zeros elif not batch_factor: optimizer.zero_grad( ) # Intialize the hidden weight to all zeros #print("i",i," h_id",h_id,"iter_count", iter_count[h_id],iter_count) loss.backward() # Backward pass: compute the weight if n_heads == 1 and loss < 0.00009 and i > 5000: print("early_stop") break if batch_factor and (i + 1) % batch_factor == 0: optimizer.step() elif not batch_factor: optimizer.step( ) # Optimizer: update the weights of hidden nodes #print("i",i,"h_id",h_id, "batch_count",batch_count) if iter_count[h_id] % 200 == 0 and batch_count == 1: #print(i,"hooop",iter_count[h_id]) plot_loss[head_dict['head_name']].append(loss.item()) #print(len(plot_loss[head_dict['head_name']])) if (i + 1) % 100 == 0: # Logging print(head_dict["head_name"] + ' Epoch [%d/%d], Step [%d/%d], Loss: %.4f' % (epoch + 1, num_epochs, i + 1, len(cheXpert_train_dataset) // batch_size, loss)) aftertDT = datetime.datetime.now() c = aftertDT - currentDT mins, sec = divmod(c.days * 86400 + c.seconds, 60) print(mins, "mins ", sec, "secs", "-----", c.microseconds, "microsec") if show: print("showa giriyooor", show) break # break # break print('training done') aftertDT = datetime.datetime.now() c = aftertDT - currentDT mins, sec = divmod(c.days * 86400 + c.seconds, 60) print(mins, "mins ", sec, "secs") print('END--', file_name) #''' PATH = saved_model_PATH + "/" + file_name head_name_list = [head["head_name"] for head in head_arch] head_state_list = [head["head"].state_dict() for head in head_arch] optimizer_state_list = [ head['optimizer'].state_dict() for head in head_arch ] torch.save( { 'epoch': kwarg_Common["num_epochs"], 'model_state_dict': model.state_dict(), 'model_head': dict(zip(head_name_list, head_state_list) ), #saving name of the method and the head state 'optimizer_state_dict': dict( zip(head_name_list, optimizer_state_list)), 'loss': plot_loss }, PATH) curves = plot_loss_auc_n_precision_recall.Curves_AUC_PrecionnRecall( model_name=file_name, root_PATH=saved_model_PATH, mode="just_plot_loss") curves.plot_loss(plot_loss=plot_loss) #print("Rotation",plot_loss["Rotation"]) #print("Relative_Position", plot_loss["Relative_Position"]) #torch.save(model.state_dict(), PATH) print('saved model(model,optim,loss, epoch)') # to google drive')
def main(): print('Generating validation, training, and experimenting databases') data_dir = in_arg.database train_dir = data_dir + '/train' valid_dir = data_dir + '/valid' test_dir = data_dir + '/test' data_transforms = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) # Transform #for training augmentation train_transforms = transforms.Compose([ transforms.RandomRotation(15), transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize([0.485, 0.486, 0.406], [0.229, 0.224, 0.225]) ]) # TODO: Load the datasets with ImageFolder img_train_datasets = datasets.ImageFolder(train_dir, transform=train_transforms) img_test_datasets = datasets.ImageFolder(test_dir, transform=data_transforms) img_valid_datasets = datasets.ImageFolder( valid_dir, transform=data_transforms ) # Data Loading #TODO: Using the image datasets and the trainforms, define the dataloaders trainloader = torch.utils.data.DataLoader(img_train_datasets, batch_size=32, shuffle=True) testloader = torch.utils.data.DataLoader(img_test_datasets, batch_size=32, shuffle=True) validationloader = torch.utils.data.DataLoader(img_valid_datasets, batch_size=32, shuffle=True) def view_batch(title, bunch): plt.figure(figsize=(12, 12)) grid = utils.make_grid(bunch[0], normalize=True) plt.imshow(grid.numpy().transpose((1, 2, 0))) plt.title(title) pass bunch = next(iter(testloader)) view_batch('Batch to Testloader', bunch) print('Finshed and Creating model') with open('cat_to_name.json', 'r') as f: cat_to_name = json.load(f) #--arch can also be used as a different architectures available from torchvision.models if in_arg.vgg16 == True: model = models.vgg16(pretrained=True) input_size = model.classifier[0].in_features print('VGG16 is CNN base model') elif in_arg.dnet == True: model = models.densenet121(pretrained=True) input_size = model.classifier.in_features print('Densenet121 is CNN base model') else: model = models.vgg16(pretrained=True) input_size = model.classifier[0].in_features print('Specification Error,VGG16 CNN base model is having issues') output_size = 102 for param in model.parameters(): param.requires_grad = False from collections import OrderedDict classifier = nn.Sequential( OrderedDict([('fc1', nn.Linear(25088, 8000)), ('dp1', nn.Dropout(0.6)), ('relu', nn.ReLU()), ('fc2', nn.Linear(8000, 2000)), ('dp2', nn.Dropout(0.6)), ('relu2', nn.ReLU()), ('fc3', nn.Linear(2000, output_size)), ('output', nn.LogSoftmax(dim=1))])) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model.classifier = classifier model.to(device) print(classifier) model.classifier = classifier model.to(device) print('Finished - beginning training') criterion = torch.nn.NLLLoss() optimizer = torch.optim.SGD(model.classifier.parameters(), lr=in_arg.lr) ### model = train(model, trainloaders, testloaders, validationloaders, criterion, optimizer) print('Training Done') print('Saving model .pth file') torch.save(model.classifier.state_dict(), 'checkpoint.pth') print(model) print('Done' + 'End of program') #### Building and training the classifier ### running_loss = 0 epochs = 1 steps = 0 print_every = 80 for e in range(epochs): running_loss = 0 model.train() for inputs, labels in trainloader: steps += 1 inputs, labels = inputs.to(device), labels.to(device) optimizer.zero_grad() outputs = model.forward(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() running_loss += loss.item() if steps % print_every == 0: model.eval() with torch.no_grad(): right, final = validation(model, validationloader) print( "Epoch: {}/{}.. ".format(e + 1, epochs), "Training Loss: {:.3f}.. ".format(running_loss / print_every), "Test Loss: {:.3f}.. ".format((final - right) / final), "Test Accuracy: {:.3f}".format(right / final)) running_loss = 0 model.train() model.eval()
parser.add_argument('--num_workers', type=int, default=2) parser.add_argument('--model_save_dir', type=str, default='data/models') config = parser.parse_args() trainloader = get_loader(config.celeba_image_dir, config.attr_path, config.selected_attrs, config.celeba_crop_size, config.image_size, config.batch_size, 'CelebA', config.mode, config.num_workers) cuda = True if torch.cuda.is_available() else False #optimizer = Optimizer(params, defaults); densenet = models.densenet121( pretrained=True ) #torchvision.models.densenet121(pretrained=False, **kwargs) #model = CNN_net(densenet) d = CNN_net() d_opt = optim.Adam(d.parameters(), 0.001, [0.9, 0.999]) if torch.cuda.is_available(): d.cuda() FloatTensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor Loss = torch.nn.MSELoss( reduce=True, size_average=False) # reduce true -- one false -- a batch #transform the loss to the cuda usable if cuda: Loss.cuda()
def initialize_model(model_name, num_classes, resume_from=None): # Initialize these variables which will be set in this if statement. Each of these # variables is model specific. # The model (nn.Module) to return model_ft = None # The input image is expected to be (input_size, input_size) input_size = 0 # You may NOT use pretrained models!! use_pretrained = False # By default, all parameters will be trained (useful when you're starting from scratch) # Within this function you can set .requires_grad = False for various parameters, if you # don't want to learn them class Flatten(torch.nn.Module): def forward(self, x): batch_size = x.shape[0] return x.view(batch_size, -1) if model_name == "resnet18": """ Resnet18 """ model_ft = models.resnet18(pretrained=use_pretrained) num_ftrs = model_ft.fc.in_features # dropout = nn.Dropout() # flatten = Flatten() # hist = AHist.HistPool(num_bins=10) # layers = list(model_ft.children()) # layers.insert(-1, hist) # del layers[-1] # del layers[-2] # model_ft = nn.Sequential(*layers) model_ft.fc = nn.Linear(num_ftrs, num_classes) print(model_ft.children()) input_size = 224 elif model_name == "resnet50": """ Resnet50 """ model_ft = models.resnet50(pretrained=use_pretrained) num_ftrs = model_ft.fc.in_features # dropout = nn.Dropout(p=.2) # flatten = Flatten() # layers = list(model_ft.children()) # layers.insert(-1, flatten) # layers.insert(-1, dropout) # del layers[-1] # model_ft = nn.Sequential(*layers) # print(list(model_ft.children())) model_ft.fc = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "resnet152": """ Resnet152 """ model_ft = models.resnet152(pretrained=use_pretrained) num_ftrs = model_ft.fc.in_features dropout = nn.Dropout() flatten = Flatten() layers = list(model_ft.children()) layers.insert(-1, flatten) layers.insert(-1, dropout) del layers[-1] model_ft = nn.Sequential(*layers) # print(list(model_ft.children())) model_ft.fc = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "alexnet": """ Alexnet """ model_ft = models.alexnet(pretrained=use_pretrained) num_ftrs = model_ft.classifier[6].in_features model_ft.classifier[6] = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "vgg": """ VGG11_bn """ model_ft = models.vgg11_bn(pretrained=use_pretrained) num_ftrs = model_ft.classifier[6].in_features model_ft.classifier[6] = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == "squeezenet": """ Squeezenet """ model_ft = models.squeezenet1_0(pretrained=use_pretrained) model_ft.classifier[1] = nn.Conv2d(512, num_classes, kernel_size=(1, 1), stride=(1, 1)) model_ft.num_classes = num_classes input_size = 224 elif model_name == "densenet": """ Densenet """ model_ft = models.densenet121(pretrained=use_pretrained) num_ftrs = model_ft.classifier.in_features model_ft.classifier = nn.Linear(num_ftrs, num_classes) input_size = 224 else: raise Exception("Invalid model name!") if resume_from is not None: print("Loading weights from %s" % resume_from) x = torch.load(resume_from) model_ft.load_state_dict(x) return model_ft, input_size
def evaluate(model_name='denseNet', pretrain=True): images = os.listdir(os.getcwd() + '\ILSVRC2012_DATA' + '\\val') imageNet = torchvision.datasets.ImageFolder( os.getcwd() + '\ILSVRC2012_DATA', transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ])) # get the labels f = open(os.getcwd() + '\ILSVRC2012_validation_ground_truth.txt', "r") labels = torch.tensor( np.array([int(label[:-1]) for label in f.readlines()])) f.close() imageNet_loader = torch.utils.data.DataLoader(imageNet, batch_size=100) if model_name == 'denseNet': pretrained_model = models.densenet121(pretrained=pretrain) elif model_name == 'resNet': # res net pretrained_model = models.resnet18(pretrained=pretrain) if torch.cuda.is_available(): pretrained_model.to('cuda') labels = labels.to('cuda') subset_start = 0 subset_end = 100 total_corrects = 0 correct_prediction_images = [] ith_batch = 1 for input_batch in imageNet_loader: batch_data = input_batch[0].to('cuda') with torch.no_grad(): outputs = pretrained_model(batch_data) outputs = torch.nn.functional.softmax(outputs, dim=1) predictions = torch.argmax(outputs, dim=1) elementwise_comparison = predictions == labels[subset_start:subset_end] batch_corrects = torch.sum(elementwise_comparison).item() total_corrects += batch_corrects print('batch {} corrects: {}'.format(ith_batch, total_corrects)) if batch_corrects > 0: nplist = elementwise_comparison.cpu().numpy() correct_prediction_indices = np.where(nplist > 0)[0] # get the image name and save it in the folder correct_prediction_images += [ images[subset_start + index] for index in correct_prediction_indices ] # save it for future use with open('{}_correct_predictions.pkl'.format(model_name), 'wb') as f: pickle.dump(correct_prediction_images, f) print(correct_prediction_images) subset_start = subset_end subset_end += batch_data.shape[0] ith_batch += 1
def main(): args = get_arguments() input_layers = None output_size = None if not os.path.exists(args.save_dir): os.makedirs(args.save_dir) save_dir = os.path.join(args.save_dir, 'checkpoint.pth') if args.model == 'densenet121': input_layers = 1024 output_size = 102 model = models.densenet121(pretrained=True) for param in model.parameters(): param.requires_grad = False classifier = nn.Sequential( OrderedDict([('input', nn.Linear(1024, 550)), ('relu1', nn.ReLU()), ('dropout1', nn.Dropout(0.5)), ('linear2', nn.Linear(550, 200)), ('relu2', nn.ReLU()), ('linear3', nn.Linear(200, 102)), ('output', nn.LogSoftmax(dim=1))])) elif args.model == 'vgg19': input_layers = 25088 output_size = 102 model = models.vgg19(pretrained=True) for param in model.parameters(): param.requires_grad = False classifier = nn.Sequential( OrderedDict([('input', nn.Linear(25088, 5000)), ('relu1', nn.ReLU()), ('dropout1', nn.Dropout(0.5)), ('linear2', nn.Linear(5000, 500)), ('relu2', nn.ReLU()), ('linear3', nn.Linear(500, 102)), ('output', nn.LogSoftmax(dim=1))])) model.classifier = classifier data_loaders, image_datasets, data_transforms = data_parser(args.data_path) if args.cuda: model = model.cuda() criterion = nn.NLLLoss() optimizer = optim.Adam(model.classifier.parameters(), lr=args.lr) train_model(model, data_loaders, criterion=criterion, optimizer=optimizer, epochs=int(args.epochs), cuda=args.cuda) validate_model(model, data_loaders[2], cuda=args.cuda) checkpoint = { 'input_size': input_layers, 'output_size': output_size, 'epochs': args.epochs, 'learning_rate': args.lr, 'batch_size': 64, 'data_transforms': data_transforms, 'model': model, 'classifier': classifier, 'optimizer': optimizer.state_dict(), 'state_dict': model.state_dict(), 'class_to_idx': image_datasets[0].class_to_idx } torch.save(checkpoint, 'checkpoint.pth')
def get_model(config): # You can also refer: # - https://pytorch.org/tutorials/beginner/transfer_learning_tutorial.html # - https://pytorch.org/tutorials/beginner/finetuning_torchvision_models_tutorial.html model = None input_size = 0 if config.model_name == 'resnet': """ Resnet34 """ model = models.resnet34(pretrained=config.use_pretrained) set_parameter_requires_grad(model, config.freeze) n_features = model.fc.in_features model.fc = nn.Linear(n_features, config.n_classes) input_size = 224 elif config.model_name == 'alexnet': """ Alexnet """ model = models.alexnet(pretrained=config.use_pretrained) set_parameter_requires_grad(model, config.freeze) n_features = model.classifier[-1].in_features model.classifier[-1] = nn.Linear(n_features, config.n_classes) input_size = 224 elif config.model_name == 'vgg': """ VGG16_bn """ model = models.vgg16(pretrained=config.use_pretrained) set_parameter_requires_grad(model, config.freeze) n_features = model.classifier[-1].in_features model.classifier[-1] = nn.Linear(n_features, config.n_classes) input_size = 224 elif config.model_name == 'squeezenet': """ Squeezenet """ model = models.squeezenet1_0(pretrained=config.use_pretrained) set_parameter_requires_grad(model, config.freeze) model.classifier[-1] = nn.Conv2d( 512, config.n_classes, kernel_size=(1, 1), stride=(1, 1), ) model.n_classes = config.n_classes input_size = 224 elif config.model_name == 'densenet': """ Densenet """ model = models.densenet121(pretrained=config.use_pretrained) set_parameter_requires_grad(model, config.freeze) n_features = model.classifier.in_features model.classifier = nn.Linear(n_features, config.n_classes) input_size = 224 else: raise NotImplementedError('You need to specify model name.') return model, input_size
for j in range(inputs.size()[0]): images_so_far += 1 ax = plt.subplot(num_images // 2, 2, images_so_far) ax.axis('off') ax.set_title('predicted: {}'.format(class_names[preds[j]])) imshow(inputs.cpu().data[j]) if images_so_far == num_images: model.train(mode=was_training) return model.train(mode=was_training) #Finetune the convnet model_ft = models.resnet18(pretrained=True) model_ft = models.densenet121() num_ftrs = model_ft.fc.in_features # Here the size of each output sample is set to 2. # Alternatively, it can be generalized to nn.Linear(num_ftrs, len(class_names)). # 修改fully-connect层 model_ft.fc = nn.Linear(num_ftrs, 2) model_ft = model_ft.to(device) criterion = nn.CrossEntropyLoss() # Observe that all parameters are being optimized optimizer_ft = optim.SGD(model_ft.parameters(), lr=0.001, momentum=0.9) # Decay LR by a factor of 0.1 every 7 epochs exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1) if __name__ == '__main__': # # Get a batch of training data # inputs, classes = next(iter(dataloaders['train']))
def __init__(self, network: str, depth: int, wildcat: bool, classes: int, maps: int, alpha: float, pretrained: bool = False, get_map: bool = False): super(Architecture, self).__init__() self.wildcat = wildcat self.get_map = get_map self.network = network if self.network == 'densenet': if depth == 121: model = models.densenet121(pretrained, progress=False) elif depth == 169: model = models.densenet169(pretrained, progress=False) else: raise ValueError('Unsupported model depth, must be one of 121, 169') in_ftrs = model.classifier.in_features pool_size = 1 self.features = model.features elif self.network == 'resnet': if depth == 18: model = models.resnet18(pretrained, progress=False) elif depth == 34: model = models.resnet34(pretrained, progress=False) elif depth == 50: model = models.resnet50(pretrained, progress=False) elif depth == 101: model = models.resnet101(pretrained, progress=False) elif depth == 152: model = models.resnet152(pretrained, progress=False) else: raise ValueError('Unsupported model depth, must be one of 18, 34, 50, 101, 152') in_ftrs = model.fc.in_features pool_size = model.avgpool.output_size self.features = nn.Sequential() self.features.add_module('conv1', model.conv1) self.features.add_module('bn1', model.bn1) self.features.add_module('relu', model.relu) self.features.add_module('maxpool', model.maxpool) self.features.add_module('layer1', model.layer1) self.features.add_module('layer2', model.layer2) self.features.add_module('layer3', model.layer3) self.features.add_module('layer4', model.layer4) elif network == 'vgg': if depth == 19: model = models.vgg19(pretrained, progress=False) else: raise ValueError('Unsupported model depth, must be one of 19') in_ftrs = model.features[34].out_channels pool_size = 1 self.features = model.features else: raise ValueError('Unsupported network type, must be one of densenet, resnet, vgg') if wildcat: print('making wildcat model...', end='') self.classifier = nn.Conv2d(in_ftrs, maps * classes, kernel_size=1, stride=1, padding=0, bias=True) self.pool = nn.Sequential(ClassWisePool(maps), WildcatPool2d(alpha=alpha)) else: print('making baseline model...', end='') self.pool = nn.AdaptiveAvgPool2d(pool_size) self.classifier = nn.Linear(in_ftrs, classes)
def train_module(argument_input): # using model architecture depending on architecture input by user if argument_input.arch == 'vgg16': model_arch = models.vgg16(pretrained=True) elif argument_input.arch == 'densenet121': model_arch = models.densenet121(pretrained=True) # Loading the dataset via function def img_load(directory=argument_input.directory): data_dir = str(directory) train_dir = data_dir + '/train' valid_dir = data_dir + '/valid' test_dir = data_dir + '/test' # TODO: Define your transforms for the training, validation, and testing sets train_transforms = transforms.Compose([ transforms.RandomRotation(15), transforms.RandomResizedCrop(224), transforms.RandomVerticalFlip(), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)) ]) test_transforms = transforms.Compose([ transforms.RandomResizedCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) valid_transforms = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) # TODO: Load the datasets with ImageFolder train_datasets = datasets.ImageFolder(root=train_dir, transform=train_transforms) valid_datasets = datasets.ImageFolder(root=valid_dir, transform=valid_transforms) test_datasets = datasets.ImageFolder(root=test_dir, transform=test_transforms) # TODO: Using the image datasets and the trainforms, define the dataloaders train_loader = torch.utils.data.DataLoader(train_datasets, batch_size=64, shuffle=True) valid_loader = torch.utils.data.DataLoader(valid_datasets, batch_size=32, shuffle=True) test_loader = torch.utils.data.DataLoader(test_datasets, batch_size=64, shuffle=True) return train_loader, valid_loader, test_loader, train_datasets, valid_datasets, test_datasets # Taking returned values into variables to use it def define_model(arch=model_arch, first_layer=argument_input.first_layer, final_layer=argument_input.final_layer): # TODO: Build and train your network # loading the VGG16 pretrained networ model = arch # Freeze the parameters in features section in VGG16 # making it static and ONLY use it as a feature detector # preventing back propogation throught them for param in model.parameters(): param.requires_grad = False # Defining our new classifier # input layer will take 25088 feature cause it has to match that of the VGG16 # 1000 is the number of neurons in the next layer of my choice # 'drop' reduces the chance of Overfitting # softmax to use the outputs as probabilites between 0 and 1 classifier = nn.Sequential( OrderedDict([('fc1', nn.Linear(first_layer, 512)), ('relu', nn.ReLU()), ('drop', nn.Dropout(p=0.5)), ('fc2', nn.Linear(512, final_layer)), ('output', nn.LogSoftmax(dim=1))])) model.classifier = classifier model.to(device) return model # Training the new classifier def train_class(model, lr=argument_input.lr, criterion=argument_input.criterion, epochs=argument_input.epochs, print_every=argument_input.print_every): # defining Loss function # using the negative log liklihood loss as criterion # I'll use the gradient decent optimizer SGD which will update wieghts and parameters optimizer = optim.SGD(model.classifier.parameters(), lr=lr, momentum=0.9) for e in range(epochs): running_loss = 0 steps = 0 for ii, (inputs, labels) in enumerate(train_loader): steps += 1 inputs, labels = inputs.to(device), labels.to(device) optimizer.zero_grad() output = model.forward(inputs) loss = criterion(output, labels) loss.backward() optimizer.step() running_loss += loss.item() if steps % print_every == 0: model.eval() valid_loss = 0 accuracy = 0 for ii, (inputs2, labels2) in enumerate(valid_loader): optimizer.zero_grad() inputs2, labels2 = inputs2.to(device), labels2.to( device) model.to(device) with torch.no_grad(): output = model.forward(inputs2) valid_loss = criterion(output, labels2) ps = torch.exp(output).data equality = (labels2.data == ps.max(1)[1]) accuracy += equality.type_as( torch.FloatTensor()).mean() valid_loss = valid_loss / len(valid_loader) accuracy = accuracy / len(valid_loader) print( "Epoch: {}/{}... ".format(e + 1, epochs), "Loss: {:.4f}... ".format(running_loss / print_every), "Validation Lost {:.4f}... ".format(valid_loss), "Accuracy: {:.4f}... ".format(accuracy)) running_loss = 0 return # GPU usage depend on gpu input by user if argument_input.device == 'cuda': device = torch.device("cuda") elif argument_input.device == 'CPU': device = torch.device("cpu") train_loader, valid_loader, test_loader, train_datasets, valid_datasets, test_datasets = img_load( ) model = define_model() train_class(model) # saving model # Saving model checkpoint torch.save(model.state_dict(), argument_input.checkpoint) print('Finished training !')
def test_and_generate_result_round2(epoch_num, model_name='resnet101', img_size=320, is_multi_gpu=False): data_transform = transforms.Compose([ transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.53744068, 0.51462684, 0.52646497], [0.06178288, 0.05989952, 0.0618901]) ]) os.environ['CUDA_VISIBLE_DEVICES'] = '0' is_use_cuda = torch.cuda.is_available() if 'resnet152' == model_name.split('_')[0]: model_ft = models.resnet152(pretrained=True) my_model = resnet152.MyResNet152(model_ft) del model_ft elif 'resnet152-r2' == model_name.split('_')[0]: model_ft = models.resnet152(pretrained=True) my_model = resnet152.MyResNet152_Round2(model_ft) del model_ft elif 'resnet152-r2-2o' == model_name.split('_')[0]: model_ft = models.resnet152(pretrained=True) my_model = resnet152.MyResNet152_Round2_2out(model_ft) del model_ft elif 'resnet152-r2-2o-gmp' == model_name.split('_')[0]: model_ft = models.resnet152(pretrained=True) my_model = models.resnet152.MyResNet152_Round2_2out_GMP(model_ft) del model_ft elif 'resnet152-r2-hm-r1' == model_name.split('_')[0]: model_ft = models.resnet152(pretrained=True) my_model = models.resnet152.MyResNet152_Round2_HM_round1(model_ft) del model_ft elif 'resnet50' == model_name.split('_')[0]: model_ft = models.resnet50(pretrained=True) my_model = resnet50.MyResNet50(model_ft) del model_ft #elif 'resnet101' == model_name.split('_')[0]: #del model_ft elif 'densenet121' == model_name.split('_')[0]: model_ft = models.densenet121(pretrained=True) my_model = densenet121.MyDenseNet121(model_ft) del model_ft elif 'densenet169' == model_name.split('_')[0]: model_ft = models.densenet169(pretrained=True) my_model = densenet169.MyDenseNet169(model_ft) del model_ft elif 'densenet201' == model_name.split('_')[0]: model_ft = models.densenet201(pretrained=True) my_model = densenet201.MyDenseNet201(model_ft) del model_ft elif 'densenet161' == model_name.split('_')[0]: model_ft = models.densenet161(pretrained=True) my_model = densenet161.MyDenseNet161(model_ft) del model_ft elif 'ranet' == model_name.split('_')[0]: my_model = ranet.ResidualAttentionModel_92() elif 'senet154' == model_name.split('_')[0]: model_ft = pretrainedmodels.models.senet154(num_classes=1000, pretrained='imagenet') my_model = MySENet154(model_ft) del model_ft #else: #raise ModuleNotFoundError test_datasets = datasets.ImageFolder('/nas/home/adas/GCT_data_test/', data_transform) test_dataloaders = torch.utils.data.DataLoader(test_datasets, batch_size=16, shuffle=False, num_workers=8) #self.test_dataloader = test_dataloaders predictions = [] actuals = [] probabilities = [] for i, (inputs, labels) in enumerate(test_dataloaders): # Notice if is_use_cuda: inputs, labels = inputs.cuda(), labels.cuda() labels = labels.squeeze() #print(labels) if is_use_cuda: my_model = resnet.resnet101() my_model = torch.load( './checkpoint/resnet101/Models_epoch_5.ckpt') my_model = my_model.cuda() my_model.eval() test_files_list = inputs output = my_model(inputs) output = F.softmax(output, dim=1).data.cpu() prediction = output.argmax(dim=1, keepdim=True) #predictio= torch.Tensor.cpu(prediction).detach().numpy() predictions.extend(prediction) actuals.extend(labels.view_as(prediction)) #actual= torch.Tensor.cpu(actuals).detach().numpy()[:,-1] probabilities.extend(np.exp(output)) #print(probabilities) else: labels = labels.squeeze() #actuals= torch.Tensor.cpu(actuals).detach().numpy()[:,-1] #print(probabilities) actual = [] for i in actuals: actual.append(i.item()) prediction = [] for i in predictions: prediction.append(i.item()) probabilitie = [] #for i in probabilities: #probabilitie=np.vstack(i.item()) #print(probabilitie) ##print(actual) print('Confusion matrix:') print(confusion_matrix(actual, prediction)) print('F1 score: %f' % f1_score(actual, prediction, average='micro')) print('Accuracy score: %f' % accuracy_score(actual, prediction)) n_classes = max(actual) fpr = dict() tpr = dict() roc_auc = dict() all_y_test_i = np.array([]) all_y_predict_proba = np.array([]) for i in range(n_classes): #y_test_i = set(map(lambda x: 1 if x == i else 0, actual)) #y_test_i=(actual == i)*1 #print(y_test_i) #all_y_test_i = np.concatenate([all_y_test_i, y_test_i]) all_y_predict_proba = np.concatenate( [all_y_predict_proba, probabilities[:, i]]) fpr[i], tpr[i], _ = roc_curve(y_test_i, y_predict_proba[:, i]) roc_auc[i] = auc(fpr[i], tpr[i]) # Compute micro-average ROC curve and ROC area fpr["average"], tpr["average"], _ = roc_curve(all_y_test_i, all_y_predict_proba) roc_auc["average"] = auc(fpr["average"], tpr["average"]) #fpr, tpr, _ = roc_curve(actual, probabilities) #roc_auc = auc(fpr, tpr) #print('ROC AuC: %f'% roc_auc) plt.figure() lw = 2 plt.plot(fpr, tpr, color='darkorange', lw=lw, label='ROC curve (area = %0.2f)' % roc_auc) plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--') plt.xlim([0.0, 1.0]) plt.ylim([0.0, 1.05]) plt.xlabel('False Positive Rate') plt.ylabel('True Positive Rate') plt.title('ROC for digit=%d class' % which_class) plt.legend(loc="lower right") plt.show()
def model_size_test(): print('alexnet') model = models.alexnet() total_params = sum(param.numel() for param in model.parameters()) print(total_params) print('vgg11') model = models.vgg11() total_params = sum(param.numel() for param in model.parameters()) print(total_params) print('resnet18') model = models.resnet18() total_params = sum(param.numel() for param in model.parameters()) print(total_params) print('squeezenet1_0') model = models.squeezenet1_0() total_params = sum(param.numel() for param in model.parameters()) print(total_params) print('squeezenet1_1') model = models.squeezenet1_1() print(model) inputs = torch.randn(16, 3, 128, 128) outputs = model(inputs) print(outputs.size()) outputs = model.features(inputs) print(outputs.size()) inputs = torch.randn(16, 3, 256, 256) outputs = model(inputs) print(outputs.size()) outputs = model.features(inputs) print(outputs.size()) total_params = sum(param.numel() for param in model.parameters()) print(total_params) print('densenet121') model = models.densenet121() total_params = sum(param.numel() for param in model.parameters()) print(total_params) print('inception_v3') model = models.inception_v3() total_params = sum(param.numel() for param in model.parameters()) print(total_params) print('googlenet') model = models.googlenet() total_params = sum(param.numel() for param in model.parameters()) print(total_params) print('shufflenet_v2_x0_5') model = models.shufflenet_v2_x0_5() total_params = sum(param.numel() for param in model.parameters()) print(total_params) print('mobilenet_v2') model = models.mobilenet_v2() total_params = sum(param.numel() for param in model.parameters()) print(total_params) print('resnext50_32x4d') model = models.resnext50_32x4d() total_params = sum(param.numel() for param in model.parameters()) print(total_params) print('wide_resnet50_2') model = models.wide_resnet50_2() total_params = sum(param.numel() for param in model.parameters()) print(total_params) print('mnasnet0_5') model = models.mnasnet0_5() total_params = sum(param.numel() for param in model.parameters()) print(total_params)
def initialize_model(model_name, num_classes, feature_extract, use_pretrained=True): model_ft = None input_size = 0 if model_name == 'resnet': ''' Resnet152 ''' model_ft = models.resnet152(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.fc.in_features model_ft.fc = nn.Sequential(nn.Linear(num_ftrs, num_classes), nn.LogSoftmax(dim=1)) input_size = 224 elif model_name == 'alexnet': ''' Alexnet ''' model_ft = models.alexnet(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.classifier[6].in_features model_ft.classifier[6] = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == 'vgg': ''' VGG11_bn ''' model_ft = models.vgg16(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.classifier[6].in_features model_ft.classifier[6] = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == 'squeezenet': ''' Squeezenet ''' model_ft = models.squeezenet1_0(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) model_ft.classifier[1] = nn.Conv2d(512, num_classes, kernel_size=(1, 1), stride=(1, 1)) model_ft.num_classes = num_classes input_size = 224 elif model_name == 'densenet': ''' Densenet ''' model_ft = models.densenet121(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) num_ftrs = model_ft.classifier.in_features model_ft.classifier = nn.Linear(num_ftrs, num_classes) input_size = 224 elif model_name == 'inception': ''' Inception v3 Be careful, expects (299,299) sized images and has auxiliary output ''' model_ft = models.inception_v3(pretrained=use_pretrained) set_parameter_requires_grad(model_ft, feature_extract) # Handle the auxilary net num_ftrs = model_ft.AuxLogits.fc.in_features model_ft.AuxLogits.fc = nn.Linear(num_ftrs, num_classes) # Handle the primary net num_ftrs = model_ft.fc.in_features model_ft.fc = nn.Linear(num_ftrs, num_classes) input_size = 299 else: print('Invalid model name, exiting...') exit() return model_ft, input_size
import numpy from torchvision import models dataset = dset.ImageFolder(root="sample", transform=transforms.Compose([ transforms.Resize([224, 224]), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]), ])) dataloader = torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=False, num_workers=0) model = models.densenet121() model.classifier = nn.Linear(1024, 28) model.load_state_dict( torch.load('checkpoint/checkpoint_epoch20.pt', map_location='cpu')) model.eval() output = model(list(dataloader)[0][0]) sortedOutput, sortedIndex = torch.sort(output, descending=True) sortedIndex = sortedIndex[0][:3].tolist() genres = [ 'Action', 'Adult', 'Adventure', 'Animation', 'Biography', 'Comedy', 'Crime', 'Documentary', 'Drama', 'Family', 'Fantasy', 'Film-Noir', 'Game-Show', 'History', 'Horror', 'Music', 'Musical', 'Mystery', 'News',
def main_worker(gpu, ngpus_per_node, args): global best_acc1 args.gpu = gpu if args.gpu is not None: print("Use GPU: {} for training".format(args.gpu)) if args.distributed: if args.dist_url == "env://" and args.rank == -1: args.rank = int(os.environ["RANK"]) if args.multiprocessing_distributed: # For multiprocessing distributed training, rank needs to be the # global rank among all the processes args.rank = args.rank * ngpus_per_node + gpu dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url, world_size=args.world_size, rank=args.rank) # create model if 'efficientnet' in args.arch: # NEW if args.pretrained: model = EfficientNet.from_pretrained(args.arch, advprop=args.advprop) print("=> using pre-trained model '{}'".format(args.arch)) else: print("=> creating model '{}'".format(args.arch)) model = EfficientNet.from_name(args.arch) else: if args.pretrained: print("=> using pre-trained model '{}'".format(args.arch)) if args.arch.find('alexnet') != -1: model = models.__dict__[args.arch](pretrained=True) elif args.arch.find('inception_v3') != -1: model = models.inception_v3(pretrained=True) elif args.arch.find('densenet121') != -1: model = models.densenet121(pretrained=True) elif args.arch.find('resnet') != -1: # ResNet model = models.__dict__[args.arch](pretrained=True) else: print('### please check the args.arch for load model in training###') exit(-1) else: print("=> creating model '{}'".format(args.arch)) model = models.__dict__[args.arch]() if args.fine_tuning: print("=> transfer-learning mode + fine-tuning (train only the last FC layer)") # Freeze Previous Layers(now we are using them as features extractor) #jiangjiewei # for param in model.parameters(): # param.requires_grad = False # Fine Tuning the last Layer For the new task # juge network: alexnet, inception_v3, densennet, resnet50 if args.arch.find('alexnet') != -1: num_ftrs = model.classifier[6].in_features model.classifier[6] = nn.Linear(num_ftrs, 3) elif args.arch.find('inception_v3') != -1: num_ftrs = model.fc.in_features num_auxftrs = model.AuxLogits.fc.in_features model.fc = nn.Linear(num_ftrs, 3) model.AuxLogits.fc =nn.Linear(num_auxftrs,3) model.aux_logits = False elif args.arch.find('densenet121') != -1: num_ftrs = model.classifier.in_features model.classifier = nn.Linear(num_ftrs, 3) elif args.arch.find('resnet') != -1: # ResNet num_ftrs = model.fc.in_features model.fc = nn.Linear(num_ftrs, 3) else: print("###Error: Fine-tuning is not supported on this architecture.###") exit(-1) print(model) else: parameters = model.parameters() # name, parma_1 = model.classifier[6].parameters() # for name, param in model.named_parameters(): # if param.requires_grad: # print(name) if args.distributed: # For multiprocessing distributed, DistributedDataParallel constructor # should always set the single device scope, otherwise, # DistributedDataParallel will use all available devices. if args.gpu is not None: torch.cuda.set_device(args.gpu) model.cuda(args.gpu) # When using a single GPU per process and per # DistributedDataParallel, we need to divide the batch size # ourselves based on the total number of GPUs we have args.batch_size = int(args.batch_size / ngpus_per_node) args.workers = int(args.workers / ngpus_per_node) model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.gpu]) else: model.cuda() # DistributedDataParallel will divide and allocate batch_size to all # available GPUs if device_ids are not set model = torch.nn.parallel.DistributedDataParallel(model) elif args.gpu is not None: torch.cuda.set_device(args.gpu) model = model.cuda(args.gpu) else: # DataParallel will divide and allocate batch_size to all available GPUs if args.arch.startswith('alexnet-1') or args.arch.startswith('vgg-1'): model.features = torch.nn.DataParallel(model.features) model.cuda() else: model = torch.nn.DataParallel(model).cuda() # define loss function (criterion) and optimizer # criterion = nn.CrossEntropyLoss().cuda(args.gpu) #jiangjiewei add weight for crossentropyloss criterion = nn.CrossEntropyLoss(weight=torch.Tensor([1.5, 1.0,3.0])).cuda(args.gpu) # use_cuda = True # device = torch.device("cuda" if use_cuda else "cpu") # class_weights = torch.FloatTensor([1.0, 0.2, 1.0]).cuda() # criterion = nn.CrossEntropyLoss(weight=class_weights).to(device) if args.arch.find('alexnet') != -1: fine_tune_parameters =model.classifier[6].parameters() elif args.arch.find('inception_v3') != -1: fine_tune_parameters = model.module.fc.parameters() elif args.arch.find('densenet121') != -1: fine_tune_parameters = model.module.classifier.parameters() elif args.arch.find('resnet') != -1: # ResNet fine_tune_parameters = model.module.fc.parameters() else: print('### please check the ignored params ###') exit(-1) ignored_params = list(map(id, fine_tune_parameters)) if args.arch.find('alexnet') != -1: base_params = filter(lambda p: id(p) not in ignored_params, model.parameters()) else: base_params = filter(lambda p: id(p) not in ignored_params, model.module.parameters()) optimizer = torch.optim.SGD([{'params': base_params}, #model.parameters() {'params': fine_tune_parameters, 'lr': 10*args.lr}], lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) # optionally resume from a checkpoint if args.resume: if os.path.isfile(args.resume): print("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume) args.start_epoch = checkpoint['epoch'] best_acc1 = checkpoint['best_acc1'] if args.gpu is not None: # best_acc1 may be from a checkpoint from a different GPU best_acc1 = best_acc1.to(args.gpu) model.load_state_dict(checkpoint['state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) print("=> loaded checkpoint '{}' (epoch {})" .format(args.resume, checkpoint['epoch'])) else: print("=> no checkpoint found at '{}'".format(args.resume)) cudnn.benchmark = True # Data loading code traindir = os.path.join(args.data, 'train1') valdir = os.path.join(args.data, 'val1') if args.advprop: normalize = transforms.Lambda(lambda img: img * 2.0 - 1.0) else: normalize = transforms.Normalize(mean=[0.5765036, 0.34929818, 0.2401832], std=[0.2179051, 0.19200659, 0.17808074]) if 'efficientnet' in args.arch: image_size = EfficientNet.get_image_size(args.arch) else: image_size = args.image_size train_dataset = datasets.ImageFolder( traindir, transforms.Compose([ # transforms.Resize((256, 256), interpolation=PIL.Image.BICUBIC), # transforms.Resize((224, 224)), transforms.Resize((args.image_size, args.image_size), interpolation=PIL.Image.BICUBIC), # transforms.RandomResizedCrop((image_size, image_size) ), #RandomRotation scale=(0.9, 1.0) transforms.RandomRotation(90), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), transforms.ToTensor(), normalize, ])) print ('classes:', train_dataset.classes) # Get number of labels labels_length = len(train_dataset.classes) if args.distributed: train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset) else: train_sampler = None train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=args.batch_size, shuffle=(train_sampler is None), num_workers=args.workers, pin_memory=True, sampler=train_sampler) val_transforms = transforms.Compose([ transforms.Resize((args.image_size, args.image_size), interpolation=PIL.Image.BICUBIC), # transforms.CenterCrop((image_size,image_size)), transforms.ToTensor(), normalize, ]) val_loader = torch.utils.data.DataLoader( datasets.ImageFolder(valdir, val_transforms), batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) if args.evaluate: res = validate(val_loader, model, criterion, args) with open('res.txt', 'w') as f: print(res, file=f) return for epoch in range(args.start_epoch, args.epochs): if args.distributed: train_sampler.set_epoch(epoch) adjust_learning_rate(optimizer, epoch, args) # train for one epoch train(train_loader, model, criterion, optimizer, epoch, args) # evaluate on validation set acc1 = validate(val_loader, model, criterion, args) # remember best acc@1 and save checkpoint is_best = acc1 > best_acc1 best_acc1 = max(acc1, best_acc1) if args.arch.find('alexnet') != -1: pre_name = './alexnet' elif args.arch.find('inception_v3') != -1: pre_name = './inception_v3' elif args.arch.find('densenet121') != -1: pre_name = './densenet121' elif args.arch.find('resnet50') != -1: pre_name = './resnet50' else: print('### please check the args.arch for pre_name###') exit(-1) if not args.multiprocessing_distributed or (args.multiprocessing_distributed and args.rank % ngpus_per_node == 0): save_checkpoint({ 'epoch': epoch + 1, 'arch': args.arch, 'state_dict': model.state_dict(), 'best_acc1': best_acc1, 'optimizer' : optimizer.state_dict(), }, is_best,pre_name) # PATH = pre_name + '_fundus_net.pth' # torch.save(model.state_dict(), PATH) print('Finished Training')
def load_modle_trained(args): normalize = transforms.Normalize(mean=[0.5765036, 0.34929818, 0.2401832], std=[0.2179051, 0.19200659, 0.17808074]) val_transforms = transforms.Compose([ transforms.Resize((args.image_size, args.image_size), interpolation=PIL.Image.BICUBIC), # transforms.CenterCrop((image_size, image_size)), transforms.ToTensor(), normalize, ]) print("=> loading checkpoint###") if args.arch.find('alexnet') != -1: pre_name = './alexnet' elif args.arch.find('inception_v3') != -1: pre_name = './inception_v3' elif args.arch.find('densenet121') != -1: pre_name = './densenet121' elif args.arch.find('resnet50') != -1: pre_name = './resnet50' else: print('### please check the args.arch###') exit(-1) PATH = pre_name + '_model_best.pth.tar' # PATH = './densenet_nodatanocost_best.ckpt' # PATH = pre_name + '_checkpoint.pth.tar' if args.arch.find('alexnet') != -1: model = models.__dict__[args.arch](pretrained=True) num_ftrs = model.classifier[6].in_features model.classifier[6] = nn.Linear(num_ftrs, 3) elif args.arch.find('inception_v3') != -1: model = models.inception_v3(pretrained=True) num_ftrs = model.fc.in_features num_auxftrs = model.AuxLogits.fc.in_features model.fc = nn.Linear(num_ftrs, 3) model.AuxLogits.fc = nn.Linear(num_auxftrs, 3) model.aux_logits = False elif args.arch.find('densenet121') != -1: model = models.densenet121(pretrained=True) num_ftrs = model.classifier.in_features model.classifier = nn.Linear(num_ftrs, 3) elif args.arch.find('resnet') != -1: # ResNet model = models.__dict__[args.arch](pretrained=True) num_ftrs = model.fc.in_features model.fc = nn.Linear(num_ftrs, 3) else: print('### please check the args.arch for load model in testing###') exit(-1) print(model) if args.arch.find('alexnet') == -1: model = torch.nn.DataParallel(model).cuda() #for modles trained by multi GPUs: densenet inception_v3 resnet50 checkpoint = torch.load(PATH) model.load_state_dict(checkpoint['state_dict']) if args.arch.find('alexnet') != -1: model = torch.nn.DataParallel(model).cuda() #for models trained by single GPU: Alexnet start_epoch = checkpoint['epoch'] best_acc1 = checkpoint['best_acc1'] print('best_epoch and best_acc1 is: ' ,start_epoch , best_acc1) return args, model, val_transforms
def dn121(pre): return children(densenet121(pre))[0] @_fastai_model('Densenet-169', 'Densely Connected Convolutional Networks',
transform=train_transforms) test_data = datasets.ImageFolder(data_dir + '/test', transform=test_transforms) trainloader = torch.utils.data.DataLoader(train_data, batch_size=32) testloader = torch.utils.data.DataLoader(test_data, batch_size=32) # Sanity check images, labels = next(iter(trainloader)) #helper.imshow(images[0], normalize=True) images, labels = next(iter(testloader)) #helper.imshow(images[0], normalize=True) # Let's use one of the pre-trained models from the PyTorch library # We will use DenseNet121. There are 121 layers model = models.densenet121( pretrained=True) # pretrained network will be downloaded # Let's take a look model # This network is trained for ImageNet dataset. With its current classifier it won't work with our classification # problem. model.classifier # We will keep the features as they are, but we will replace the Fully Connected layer with our own # and optimize this new FC's parameters during training. So we need to freeze all the layers before the classifier # Freeze our feature parameters: for param in model.parameters(): param.requires_grad = False # The gradients will not be calculated # Let's build our own classifier, a fully connected network with 2 hidden layers # Use Sequential with OrderedDict classifier = nn.Sequential( OrderedDict([('fc1', nn.Linear(1024, 500)), ('relu', nn.ReLU()),
# * 使用反向传播训练分类器层,并使用预训练的网络获取特征 # * 跟踪验证集的损失和准确率,以确定最佳超参数 # # 我们在下面为你留了一个空的单元格,但是你可以使用多个单元格。建议将问题拆分为更小的部分,并单独运行。检查确保每部分都达到预期效果,然后再完成下个部分。你可能会发现,当你实现每部分时,可能需要回去修改之前的代码,这很正常! # # 训练时,确保仅更新前馈网络的权重。如果一切构建正确的话,验证准确率应该能够超过 70%。确保尝试不同的超参数(学习速率、分类器中的单元、周期等),寻找最佳模型。保存这些超参数并用作项目下个部分的默认值。 # In[17]: # TODO: Build and train your network device = "cuda:0" if torch.cuda.is_available() else "cpu" model = models.densenet121(pretrained = True) model.name = 'densenet121' # In[18]: for param in model.parameters(): param.requires_grad= False # hyperparameters for classifier input_size = [each.in_features for each in model.classifier.modules() if type(each) == torch.nn.modules.linear.Linear][0] hidden_layers = [512] output_size = 102 drop_p = 0.5 epochs = 30
def train_cnn(PATH_TO_IMAGES, LR, WEIGHT_DECAY): """ Train torchvision model to NIH data given high level hyperparameters. Args: PATH_TO_IMAGES: path to NIH images LR: learning rate WEIGHT_DECAY: weight decay parameter for SGD Returns: preds: torchvision model predictions on test fold with ground truth for comparison aucs: AUCs for each train,test tuple """ NUM_EPOCHS = 100 BATCH_SIZE = 16 try: rmtree('results/') except BaseException: pass # directory doesn't yet exist, no need to clear it os.makedirs("results/") # use imagenet mean,std for normalization mean = [0.485, 0.456, 0.406] std = [0.229, 0.224, 0.225] N_LABELS = 14 # we are predicting 14 labels # load labels df = pd.read_csv("nih_labels.csv", index_col=0) # define torchvision transforms data_transforms = { 'train': transforms.Compose([ transforms.RandomHorizontalFlip(), transforms.Scale(224), # because scale doesn't always give 224 x 224, this ensures 224 x # 224 transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean, std) ]), 'val': transforms.Compose([ transforms.Scale(224), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean, std) ]), } # create train/val dataloaders transformed_datasets = {} transformed_datasets['train'] = CXR.CXRDataset( path_to_images=PATH_TO_IMAGES, fold='train', transform=data_transforms['train']) transformed_datasets['val'] = CXR.CXRDataset( path_to_images=PATH_TO_IMAGES, fold='val', transform=data_transforms['val']) dataloaders = {} dataloaders['train'] = torch.utils.data.DataLoader( transformed_datasets['train'], batch_size=BATCH_SIZE, shuffle=True, num_workers=8) dataloaders['val'] = torch.utils.data.DataLoader( transformed_datasets['val'], batch_size=BATCH_SIZE, shuffle=True, num_workers=8) # please do not attempt to train without GPU as will take excessively long if not use_gpu: raise ValueError("Error, requires GPU") model = models.densenet121(pretrained=True) num_ftrs = model.classifier.in_features # add final layer with # outputs in same dimension of labels with sigmoid # activation model.classifier = nn.Sequential( nn.Linear(num_ftrs, N_LABELS), nn.Sigmoid()) # put model on GPU model = model.cuda() # define criterion, optimizer for training criterion = nn.BCELoss() optimizer = optim.SGD( filter( lambda p: p.requires_grad, model.parameters()), lr=LR, momentum=0.9, weight_decay=WEIGHT_DECAY) dataset_sizes = {x: len(transformed_datasets[x]) for x in ['train', 'val']} # train model model, best_epoch = train_model(model, criterion, optimizer, LR, num_epochs=NUM_EPOCHS, dataloaders=dataloaders, dataset_sizes=dataset_sizes, weight_decay=WEIGHT_DECAY) # get preds and AUCs on test fold preds, aucs = E.make_pred_multilabel( data_transforms, model, PATH_TO_IMAGES) return preds, aucs