def densenet161(num_classes=1000, pretrained='imagenet'): r"""Densenet-161 model from `"Densely Connected Convolutional Networks" <https://arxiv.org/pdf/1608.06993.pdf>` """ model = models.densenet161(pretrained=False) if pretrained is not None: settings = pretrained_settings['densenet161'][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 _initialize_model(self): # Initialize these variables which will be set in this if statement. Each of these # variables is model specific. self.model = None self.input_size = 0 if self.model_name == "resnet": """ Resnet18 """ self.model = models.resnet18(pretrained=self.use_pretrained) self._set_parameter_requires_grad() num_ftrs = self.model.fc.in_features self.model.fc = nn.Linear(num_ftrs, self.num_classes) self.input_size = 224 elif self.model_name == "alexnet": """ Alexnet """ self.model = models.alexnet(pretrained=self.use_pretrained) self._set_parameter_requires_grad() num_ftrs = self.model.classifier[6].in_features self.model.classifier[6] = nn.Linear(num_ftrs, self.num_classes) self.input_size = 224 elif self.model_name == "vgg": """ VGG16_bn """ self.model = models.vgg16(pretrained=self.use_pretrained) self._set_parameter_requires_grad() num_ftrs = self.model.classifier[6].in_features self.model.classifier[6] = nn.Linear(num_ftrs, self.num_classes) self.input_size = 224 elif self.model_name == "squeezenet": """ Squeezenet """ self.model = models.squeezenet1_0(pretrained=self.use_pretrained) self._set_parameter_requires_grad() self.model.classifier[1] = nn.Conv2d(512, self.num_classes, kernel_size=(1, 1), stride=(1, 1)) self.model.num_classes = self.num_classes self.input_size = 224 elif self.model_name == "densenet": """ Densenet """ self.model = models.densenet161(pretrained=self.use_pretrained) self._set_parameter_requires_grad() num_ftrs = self.model.classifier.in_features self.model.classifier = nn.Linear(num_ftrs, self.num_classes) self.input_size = 224 elif self.model_name == "inception": """ Inception v3 Be careful, expects (299,299) sized images and has auxiliary output """ self.model = models.inception_v3(pretrained=self.use_pretrained) self._set_parameter_requires_grad() # Handle the auxilary net num_ftrs = self.model.AuxLogits.fc.in_features self.model.AuxLogits.fc = nn.Linear(num_ftrs, self.num_classes) # Handle the primary net num_ftrs = self.model.fc.in_features self.model.fc = nn.Linear(num_ftrs, self.num_classes) self.input_size = 299 else: print("Invalid model name, exiting...") exit()
def get_models(config): model_name = config['model_name'] input_size = 224 if 'vgg' in model_name: if model_name == 'vgg16': model = models.vgg16(pretrained=True) elif model_name == 'vgg19': model = models.vgg19(pretrained=True) elif model_name == 'vgg16_bn': model = models.vgg16_bn(pretrained=True) elif model_name == 'vgg19_bn': model = models.vgg19_bn(pretrained=True) for p in model.parameters(): p.requires_grad = False #model.classifier[0] = nn.Linear(in_features=25088, out_features=4096) #model.classifier[3] = nn.Linear(in_features=4096, out_features=4096) model.classifier[6] = nn.Linear(in_features=4096, out_features=config['num_used_classes']) elif 'res' in model_name: if model_name == 'resnet50': model = models.resnet50(pretrained=True) elif model_name == 'resnet101': model = models.resnet101(pretrained=True) elif model_name == 'resnet152': model = models.resnet152(pretrained=True) elif model_name == 'resnext50_32x8d': model = models.resnext50_32x4d(pretrained=True) elif model_name == 'resnext101_32x8d': model = models.resnext101_32x8d(pretrained=True) elif model_name == 'wide_resnet50_2': model = models.wide_resnet50_2(pretrained=True) elif model_name == 'wide_resnet101_2': model = models.wide_resnet101_2(pretrained=True) for p in model.parameters(): p.requires_grad = False model.fc = nn.Linear(in_features=2048, out_features=config['num_used_classes']) elif 'inception' in model_name: if model_name == 'inception_v3': model = models.inception_v3(pretrained=True) for p in model.parameters(): p.requires_grad = False num_ftrs = model.AuxLogits.fc.in_features model.AuxLogits.fc = nn.Linear(num_ftrs, config['num_used_classes']) # Handle the primary net num_ftrs = model.fc.in_features model.fc = nn.Linear(num_ftrs, config['num_used_classes']) input_size = 299 elif 'densenet' in model_name: if model_name == 'densenet121': model = models.densenet121(pretrained=True) if model_name == 'densenet161': model = models.densenet161(pretrained=True) if model_name == 'densenet169': model = models.densenet169(pretrained=True) if model_name == 'densenet201': model = models.densenet201(pretrained=True) for p in model.parameters(): p.requires_grad = False num_ftrs = model.classifier.in_features model.classifier = nn.Linear(num_ftrs, config['num_used_classes']) return model, input_size
val_loader = torch.utils.data.DataLoader(val1, batch_size=500,shuffle=True, num_workers=0) lr_values = np.array([0.00005])#, 0.0001, 0.0002]) #for the fc net best_lr = [] best_acc = 0 k = 0 #TUNING for lr in lr_values: k += 1 print("##### ROUND "+str(k)+" #####") model_ft = models.densenet161(pretrained=True) for param in model_ft.features.parameters(): param.requires_grad = False num_ftrs = model_ft.classifier.in_features model_ft.classifier = nn.Linear(num_ftrs, 5) #LOAD MODEL PARAMETERS IF NEEDED #model_ft.load_state_dict(torch.load("models/test.pth.tar")) if use_gpu: model_ft = model_ft.cuda() print("\nModel loaded in CUDA") print("\nlr: "+str(lr))
def training(architecture, n_epoch, hidden_units, learning_rate): t = time.time() n_input = None n_output = 102 if architecture == 'densenet': densenet161 = models.densenet161(pretrained=True) models_select = {'densenet': densenet161} model = models_select[architecture] for param in model.parameters(): param.requires_grad = False n_input = 2208 classifier = nn.Sequential( OrderedDict([('fc1', nn.Linear(n_input, hidden_units)), ('relu', nn.ReLU()), ('dropout', nn.Dropout(0.5)), ('fc2', nn.Linear(hidden_units, n_output)), ('output', nn.LogSoftmax(dim=1))])) model.classifier = classifier criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.classifier.parameters(), lr=learning_rate, momentum=0.9) elif architecture == 'vgg': vgg16 = models.vgg16(pretrained=True) models_select = {'vgg': vgg16} model = models_select[architecture] for param in model.parameters(): param.requires_grad = False n_input = 4096 classifier = nn.Sequential( OrderedDict([('fc1', nn.Linear(n_input, hidden_units)), ('relu', nn.ReLU()), ('dropout', nn.Dropout(0.5)), ('fc2', nn.Linear(hidden_units, n_output)), ('output', nn.LogSoftmax(dim=1))])) model.classifier[6] = classifier criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.classifier[6].parameters(), lr=learning_rate, momentum=0.9) epochs = n_epoch steps = 0 running_loss = 0 accuracy_per_epoch = [] best_val_accuracy = None train_len = 80 trainloader, validloader, testloader, train_dataset = data_load() device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model.to(device) t = time.time() for epoch in range(epochs): for inputs, labels in trainloader: steps += 1 inputs, labels = inputs.to(device), labels.to(device) optimizer.zero_grad() logits = model.forward(inputs) loss = criterion(logits, labels) loss.backward() optimizer.step() running_loss += loss.item() if steps % train_len == 0: test_loss = 0 accuracy = 0 model.eval() with torch.no_grad(): for inputs, labels in validloader: inputs, labels = inputs.to(device), labels.to(device) logits = model.forward(inputs) batch_loss = criterion(logits, labels) test_loss += batch_loss.item() ps = torch.exp(logits) top_p, top_class = ps.topk(1, dim=1) equals = top_class == labels.view(*top_class.shape) accuracy += torch.mean(equals.type( torch.FloatTensor)).item() running_loss = 0 model.train() print(f'\nEpoch: {epoch+1}/{epochs}.. ' f'\nTraining Loss = {running_loss/train_len:.3f}.. ' f'\nValidation Loss = {test_loss/len(validloader):.3f}.. ' f'\nAccuracy = {accuracy/len(validloader)*100:.1f}..') accuracy_per_epoch.append(accuracy / len(validloader) * 100) time_elapsed = time.time() - t print('\n') print('\nTraining completed in {:.0f} min {:.0f} sec'.format( time_elapsed // 60, time_elapsed % 60)) best_val_accuracy = max(float(val) for val in accuracy_per_epoch) print("\nBest val accuracy = {:.1f}".format(best_val_accuracy)) print('\n\n** Saving checkpoint ...') model.class_to_idx = train_dataset.class_to_idx checkpoint = { 'arch': architecture, 'optimizer': optimizer.state_dict(), 'state_dict': model.state_dict(), 'epochs': epoch, 'learning_rate': learning_rate, 'class_to_idx': model.class_to_idx } checkpoint_saver(checkpoint)
def dn161(pre): return children(densenet161(pre))[0]
def __init__(self, num_classes=2, feature='Alex', feature_shape=(256,25,25), pretrained=True, requires_grad=False): super(CNN, self).__init__() # Feature Extraction if(feature=='Alex'): self.ft_ext = models.alexnet(pretrained=pretrained) self.ft_ext_modules = list(self.ft_ext.children())[:-1] elif(feature=='Res'): self.ft_ext = models.resnet50(pretrained=pretrained) self.ft_ext_modules=list(self.ft_ext.children())[:-2] elif(feature=='Squeeze'): self.ft_ext = models.squeezenet1_1(pretrained=pretrained) self.ft_ext_modules=list(self.ft_ext.children())[:-1] elif(feature=='Dense'): self.ft_ext = models.densenet161(pretrained=pretrained) self.ft_ext_modules=list(self.ft_ext.children())[:-1] self.ft_ext=nn.Sequential(*self.ft_ext_modules) for p in self.ft_ext.parameters(): p.requires_grad = requires_grad # Classifier if(feature=='Res'): conv1_output_features = int(feature_shape[0]/4) else: conv1_output_features = int(feature_shape[0]/2) fc_1_input_features = conv1_output_features*int(feature_shape[1]/2)*int(feature_shape[2]/2) fc1_output_features = 256 fc2_output_features = 64 self.conv1 = nn.Sequential( nn.Conv2d( in_channels=feature_shape[0], out_channels=conv1_output_features, kernel_size=1, ), nn.BatchNorm2d(conv1_output_features), nn.ReLU(), nn.MaxPool2d(kernel_size=2) ) self.fc1 = nn.Sequential( nn.Linear(fc_1_input_features, fc1_output_features), nn.BatchNorm1d(fc1_output_features), nn.ReLU() ) self.fc2 = nn.Sequential( nn.Linear(fc1_output_features, fc2_output_features), nn.BatchNorm1d(fc2_output_features), nn.ReLU() ) self.out = nn.Linear(fc2_output_features, num_classes)
def __init__(self, num_classes, input_size, k=7): super(GCN_COMBINED, self).__init__() self.K = k self.input_size = input_size dense161_path = os.path.join(pretrained_dir, 'densenet161.pth') densenet = models.densenet161() densenet.load_state_dict(torch.load(dense161_path)) self.layer0 = nn.Sequential( densenet.features.conv0, densenet.features.norm0, densenet.features.relu0, ) self.layer1 = nn.Sequential( densenet.features.pool0, densenet.features.denseblock1, ) self.layer2 = nn.Sequential( densenet.features.transition1, densenet.features.denseblock2, ) self.layer3 = nn.Sequential( densenet.features.transition2, densenet.features.denseblock3, ) self.layer4 = nn.Sequential( densenet.features.transition3, densenet.features.denseblock4, ) self.gcm1 = _GlobalConvModule(2208, num_classes, (self.K, self.K)) self.gcm2 = _GlobalConvModule(2112, num_classes, (self.K, self.K)) self.gcm3 = _GlobalConvModule(768, num_classes, (self.K, self.K)) self.gcm4 = _GlobalConvModule(384, num_classes, (self.K, self.K)) self.brm1 = _BoundaryRefineModule(num_classes) self.brm2 = _BoundaryRefineModule(num_classes) self.brm3 = _BoundaryRefineModule(num_classes) self.brm4 = _BoundaryRefineModule(num_classes) self.brm5 = _BoundaryRefineModule(num_classes) self.brm6 = _BoundaryRefineModule(num_classes) self.brm7 = _BoundaryRefineModule(num_classes) self.brm8 = _BoundaryRefineModule(num_classes) self.brm9 = _BoundaryRefineModule(num_classes) self.deconv = _LearnedBilinearDeconvModule(num_classes) self.psp = _PyramidPoolingModule(num_classes, 12, input_size, levels=(1, 2, 3, 6, 9)) self.final = nn.Sequential( nn.Conv2d(num_classes + self.psp.out_channels, num_classes, kernel_size=3, padding=1), nn.BatchNorm2d(num_classes), nn.ReLU(inplace=True), nn.Conv2d(num_classes, num_classes, kernel_size=1, padding=0)) initialize_weights(self.gcm1, self.gcm2, self.gcm3, self.gcm4, self.brm1, self.brm2, self.brm3, self.brm4, self.brm5, self.brm6, self.brm7, self.brm8, self.brm9) initialize_weights(self.psp, self.final)
model.classifier[6] = nn.Linear(num_ftrs,nnClassCount) criterion = nn.BCELoss(size_average = True) elif trNetName == "Vgg19": model = models.vgg19_bn(pretrained=usePreTrain) set_parameter_requires_grad(model, feature_extract) num_ftrs = model.classifier[6].in_features model.classifier[6] = nn.Linear(num_ftrs,nnClassCount) criterion = nn.BCELoss(size_average = True) elif trNetName == "DenseNet121": model = models.densenet121(pretrained=usePreTrain) set_parameter_requires_grad(model, feature_extract) num_ftrs = model.classifier.in_features model.classifier = nn.Linear(num_ftrs, nnClassCount) criterion = nn.BCELoss(size_average = True) elif trNetName == "DenseNet161": model = models.densenet161(pretrained=usePreTrain) set_parameter_requires_grad(model, feature_extract) num_ftrs = model.classifier.in_features model.classifier = nn.Linear(num_ftrs, nnClassCount) criterion = nn.BCELoss(size_average = True) elif trNetName == "DenseNet169": model = models.densenet169(pretrained=usePreTrain) set_parameter_requires_grad(model, feature_extract) num_ftrs = model.classifier.in_features model.classifier = nn.Linear(num_ftrs, nnClassCount) criterion = nn.BCELoss(size_average = True) elif trNetName == "DenseNet201": model = models.densenet201(pretrained=usePreTrain) set_parameter_requires_grad(model, feature_extract) num_ftrs = model.classifier.in_features model.classifier = nn.Linear(num_ftrs, nnClassCount)
imshow(inputs.cpu().data[j]) if images_so_far == num_images: model.train(mode=was_training) return model.train(mode=was_training) ###################################################################### # Finetuning the convnet # ---------------------- # # Load a pretrained model and reset final fully connected layer. # model_ft = models.densenet161(pretrained=False) #num_ftrs = model_ft.fc.in_features #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) ###################################################################### # Train and evaluate
def instantiate_model (dataset='cifar10', num_classes=10, input_quant='FP', arch='resnet', dorefa=False, abit=32, wbit=32, qin=False, qout=False, suffix='', load=False, torch_weights=False, device='cpu'): """Initializes/load network with random weight/saved and return auto generated model name 'dataset_arch_suffix.ckpt' Args: dataset : mnists/cifar10/cifar100/imagenet/tinyimagenet/simple dataset the netwoek is trained on. Used in model name num_classes : number of classes in dataset. arch : resnet/vgg/lenet5/basicnet/slpconv model architecture the network to be instantiated with suffix : str appended to the model name load : boolean variable to indicate load pretrained model from ./pretrained/dataset/ torch_weights : boolean variable to indicate load weight from torchvision for imagenet dataset Returns: model : models with desired weight (pretrained / random ) model_name : str 'dataset_arch_suffix.ckpt' used to save/load model in ./pretrained/dataset """ #Select the input transformation if input_quant==None: input_quant='' Q=PreProcess() elif input_quant.lower()=='q1': Q = Quantise2d(n_bits=1).to(device) elif input_quant.lower()=='q2': Q = Quantise2d(n_bits=2).to(device) elif input_quant.lower()=='q4': Q = Quantise2d(n_bits=4).to(device) elif input_quant.lower()=='q6': Q = Quantise2d(n_bits=6).to(device) elif input_quant.lower()=='q8': Q = Quantise2d(n_bits=8).to(device) elif input_quant.lower()=='fp': Q = Quantise2d(n_bits=1,quantise=False).to(device) else: raise ValueError # Instantiate model1 # RESNET IMAGENET if(arch == 'torch_resnet18'): if dorefa: raise ValueError ("Dorefa net unsupported for {}".format(arch)) else: model = models.resnet18(pretrained=torch_weights) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix elif(arch == 'torch_resnet34'): if dorefa: raise ValueError ("Dorefa net unsupported for {}".format(arch)) else: model = models.resnet34(pretrained=torch_weights) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix elif(arch == 'torch_resnet50'): if dorefa: raise ValueError ("Dorefa net unsupported for {}".format(arch)) else: model = models.resnet50(pretrained=torch_weights) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix elif(arch == 'torch_resnet101'): if dorefa: raise ValueError ("Dorefa net unsupported for {}".format(arch)) else: model = models.resnet101(pretrained=torch_weights) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix elif(arch == 'torch_resnet152'): if dorefa: raise ValueError ("Dorefa net unsupported for {}".format(arch)) else: model = models.resnet152(pretrained=torch_weights) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix elif(arch == 'torch_resnet34'): if dorefa: raise ValueError ("Dorefa net unsupported for {}".format(arch)) else: model = models.resnet34(pretrained=torch_weights) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix elif(arch == 'torch_resnext50_32x4d'): if dorefa: raise ValueError ("Dorefa net unsupported for {}".format(arch)) else: model = models.resnext50_32x4d(pretrained=torch_weights) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix elif(arch == 'torch_resnext101_32x8d'): if dorefa: raise ValueError ("Dorefa net unsupported for {}".format(arch)) else: model = models.resnext101_32x8d(pretrained=torch_weights) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix elif(arch == 'torch_wide_resnet50_2'): if dorefa: raise ValueError ("Dorefa net unsupported for {}".format(arch)) else: model = models.wide_resnet50_2(pretrained=torch_weights) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix elif(arch == 'torch_wide_resnet101_2'): if dorefa: raise ValueError ("Dorefa net unsupported for {}".format(arch)) else: model = models.wide_resnet101_2(pretrained=torch_weights) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix #VGG IMAGENET elif(arch == 'torch_vgg11'): if dorefa: raise ValueError ("Dorefa net unsupported for {}".format(arch)) else: model = models.vgg11(pretrained=torch_weights) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix elif(arch == 'torch_vgg11bn'): if dorefa: raise ValueError ("Dorefa net unsupported for {}".format(arch)) else: model = models.vgg11_bn(pretrained=torch_weights) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix elif(arch == 'torch_vgg13'): if dorefa: raise ValueError ("Dorefa net unsupported for {}".format(arch)) else: model = models.vgg13(pretrained=torch_weights) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix elif(arch == 'torch_vgg13bn'): if dorefa: raise ValueError ("Dorefa net unsupported for {}".format(arch)) else: model = models.vgg13_bn(pretrained=torch_weights) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix elif(arch == 'torch_vgg16'): if dorefa: raise ValueError ("Dorefa net unsupported for {}".format(arch)) else: model = models.vgg16(pretrained=torch_weights) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix elif(arch == 'torch_vgg16bn'): if dorefa: raise ValueError ("Dorefa net unsupported for {}".format(arch)) else: model = models.vgg16_bn(pretrained=torch_weights) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix elif(arch == 'torch_vgg19'): if dorefa: raise ValueError ("Dorefa net unsupported for {}".format(arch)) else: model = models.vgg19(pretrained=torch_weights) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix elif(arch == 'torch_vgg19bn'): if dorefa: raise ValueError ("Dorefa net unsupported for {}".format(arch)) else: model = models.vgg19_bn(pretrained=torch_weights) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix #MOBILENET IMAGENET elif(arch == 'torch_mobnet'): if dorefa: raise ValueError ("Dorefa net unsupported for {}".format(arch)) else: model = models.mobilenet_v2(pretrained=torch_weights) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix #DENSENET IMAGENET elif(arch == 'torch_densenet121'): if dorefa: raise ValueError ("Dorefa net unsupported for {}".format(arch)) else: model = models.densenet121(pretrained=torch_weights) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix elif(arch == 'torch_densenet169'): if dorefa: raise ValueError ("Dorefa net unsupported for {}".format(arch)) else: model = models.densenet169(pretrained=torch_weights) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix elif(arch == 'torch_densenet201'): if dorefa: raise ValueError ("Dorefa net unsupported for {}".format(arch)) else: model = models.densenet201(pretrained=torch_weights) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix elif(arch == 'torch_densenet161'): if dorefa: raise ValueError ("Dorefa net unsupported for {}".format(arch)) else: model = models.densenet161(pretrained=torch_weights) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix #RESNET CIFAR elif(arch[0:6] == 'resnet'): cfg = arch[6:] if dorefa: model = ResNet_Dorefa_(cfg=cfg, num_classes=num_classes, a_bit=abit, w_bit=wbit) model_name = dataset.lower()+ "_" + input_quant + "_" + arch +"_a" + str(abit) + 'w'+ str(wbit) + suffix else: model = ResNet_(cfg=cfg, num_classes=num_classes) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix #VGG CIFAR elif(arch[0:3] == 'vgg'): len_arch = len(arch) if arch[len_arch-2:len_arch]=='bn' and arch[len_arch-4:len_arch-2]=='bn': batch_norm_conv=True batch_norm_linear=True cfg= arch[3:len_arch-4] elif arch [len_arch-2: len_arch]=='bn': batch_norm_conv=True batch_norm_linear=False cfg= arch[3:len_arch-2] else: batch_norm_conv=False batch_norm_linear=False cfg= arch[3:len_arch] if dorefa: model = vgg_Dorefa(cfg=cfg, batch_norm_conv=batch_norm_conv, batch_norm_linear=batch_norm_linear ,num_classes=num_classes, a_bit=abit, w_bit=wbit) model_name = dataset.lower()+ "_" + input_quant + "_" + arch +"_a" + str(abit) + 'w'+ str(wbit) + suffix else: model = vgg(cfg=cfg, batch_norm_conv=batch_norm_conv, batch_norm_linear=batch_norm_linear ,num_classes=num_classes) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix # LENET MNIST elif (arch == 'lenet5'): if dorefa: model = LeNet5_Dorefa(num_classes=num_classes, abit=abit, wbit=wbit) model_name = dataset.lower()+ "_" + input_quant + "_" + arch +"_a" + str(abit) + 'w'+ str(wbit) + suffix else: model = LeNet5(num_classes=num_classes) model_name = dataset.lower()+ "_" + input_quant + "_" + arch + suffix else: # Right way to handle exception in python see https://stackoverflow.com/questions/2052390/manually-raising-throwing-an-exception-in-python # Explains all the traps of using exception, does a good job!! I mean the link :) raise ValueError("Unsupported neural net architecture") model = model.to(device) if load == True and torch_weights == False : print(" Using Model: " + arch) if model_name[-4:]=='_tfr': model_path = os.path.join('./pretrained/', dataset.lower(), model_name + '.tfr') else: model_path = os.path.join('./pretrained/', dataset.lower(), model_name + '.ckpt') model.load_state_dict(torch.load(model_path, map_location='cuda:0')) print(' Loaded trained model from :' + model_path) print(' {}'.format(Q)) else: if model_name[-4:]=='_tfr': model_path = os.path.join('./pretrained/', dataset.lower(), model_name + '.tfr') else: model_path = os.path.join('./pretrained/', dataset.lower(), model_name + '.ckpt') print(' Training model save at:' + model_path) print('') return model, model_name, Q
def __init__(self, args): super(DenseNet161, self).__init__() self._model = models.densenet161(pretrained=args.trained_on_imagenet) self._model.classifier = nn.Linear(args.rolled_size, args.num_classes)
def get_model(self): if self.args.architecture in ['resnet34', 'resnet50', 'resnet101']: if self.args.architecture == 'resnet34': model = torchmodels.resnet34(pretrained=True) if self.args.architecture == 'resnet50': model = torchmodels.resnet50(pretrained=True) if self.args.architecture == 'resnet101': model = torchmodels.resnet101(pretrained=True) num_classes = self.args.num_classes num_ftrs = model.fc.in_features model.fc = nn.Linear(num_ftrs, num_classes) if self.args.architecture in [ 'densenet121', 'densenet169', 'densenet201', 'densenet161' ]: if self.args.architecture == 'densenet121': model = torchmodels.densenet121(pretrained=True) if self.args.architecture == 'densenet169': model = torchmodels.densenet169(pretrained=True) if self.args.architecture == 'densenet201': model = torchmodels.densenet201(pretrained=True) if self.args.architecture == 'densenet161': model = torchmodels.densenet161(pretrained=True) num_classes = self.args.num_classes num_ftrs = model.classifier.in_features model.classifier = nn.Linear(num_ftrs, num_classes) if self.args.architecture in [ 'vgg11', 'vgg11_bn', 'vgg13', 'vgg13_bn', 'vgg16', 'vgg16_bn', 'vgg19_bn', 'vgg19' ]: if self.args.architecture == 'vgg11': model = torchmodels.vgg11(pretrained=True) if self.args.architecture == 'vgg11_bn': model = torchmodels.vgg11_bn(pretrained=True) if self.args.architecture == 'vgg13': model = torchmodels.vgg13(pretrained=True) if self.args.architecture == 'vgg13_bn': model = torchmodels.vgg13_bn(pretrained=True) if self.args.architecture == 'vgg16': model = torchmodels.vgg16(pretrained=True) if self.args.architecture == 'vgg16_bn': model = torchmodels.vgg16_bn(pretrained=True) if self.args.architecture == 'vgg19_bn': model = torchmodels.vgg19_bn(pretrained=True) if self.args.architecture == 'vgg19': model = torchmodels.vgg19(pretrained=True) num_classes = self.args.num_classes in_features = model.classifier[6].in_features n_module = nn.Linear(in_features, num_classes) n_classifier = list(model.classifier.children())[:-1] n_classifier.append(n_module) model.classifier = nn.Sequential(*n_classifier) if self.args.cuda: model.cuda() return model
def train(trainloader, validloader, class_to_idx, epochs, lr, arch, hidden_units): # Build and train your network device = torch.device("cuda" if torch.cuda.is_available() else "cpu") if arch == 'densenet121': model = models.densenet121(pretrained=True) input_size = 1024 elif arch == 'densenet161': model = models.densenet161(pretrained=True) input_size = 2208 elif arch == 'vgg16': model = models.vgg16(pretrained=True) input_size = 25088 else: return Null for param in model.parameters(): param.requires_grad = False model.classifier = nn.Sequential( nn.Linear(input_size, hidden_units), nn.ReLU(), nn.Dropout(p=0.3), nn.Linear(hidden_units, len(class_to_idx)), nn.LogSoftmax(dim=1)) # Criterion criterion = nn.NLLLoss() optimizer = optim.Adam(model.classifier.parameters(), lr=lr) model.to(device) epochs = epochs steps = 0 running_loss = 0 print_every = 5 for epoch in range(epochs): for inputs, labels in trainloader: steps += 1 inputs, labels = inputs.to(device), labels.to(device) optimizer.zero_grad() logps = model.forward(inputs) loss = criterion(logps, labels) loss.backward() optimizer.step() running_loss += loss.item() if steps % print_every == 0: valid_loss = 0 accuracy = 0 model.eval() with torch.no_grad(): for inputs, labels in validloader: inputs, labels = inputs.to(device), labels.to(device) logps = model.forward(inputs) batch_loss = criterion(logps, labels) valid_loss += batch_loss.item() ps = torch.exp(logps) top_p, top_class = ps.topk(1, dim=1) equals = top_class == labels.view(*top_class.shape) accuracy += torch.mean(equals.type(torch.FloatTensor)) print(f'Epoch {epoch+1}/{epochs}.. ' f'Validation loss: {running_loss/print_every:.3f}.. ' f'Validation loss: {valid_loss/len(validloader):.3f}.. ' f'Validation accuracy: {accuracy/len(validloader):.3f}') running_loss = 0 model.train() # TODO: Save the checkpoint model.class_to_idx = class_to_idx torch.save(model, 'checkpoint.pth') #torch.save(model.state_dict(), filepath) #torch.save(checkpoint, 'checkpoint.pth') print("Model saved to 'checkpoint.pth'")
train_on_gpu = torch.cuda.is_available() if not train_on_gpu: print('CUDA is not available. Training on CPU ...') else: print('CUDA is available! Training on GPU ...') ImageFile.LOAD_TRUNCATED_IMAGES = True #!pip install --upgrade wandb test_transforms = transforms.Compose([ transforms.Resize(255), # transforms.CenterCrop(224), transforms.ToTensor(), ]) model = models.densenet161() model.classifier = nn.Sequential(nn.Linear(2208, 1000), nn.ReLU(), nn.Dropout(0.2), nn.Linear(1000, 2), nn.LogSoftmax(dim=1)) criterion = nn.NLLLoss() # Only train the classifier parameters, feature parameters are frozen optimizer = optim.Adam(model.parameters(), lr=0.001) scheduler = lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1) model = model.cuda() model.load_state_dict(torch.load('tensorboardexp.pt')) classes = ["accident", "noaccident"] # model.load_state_dict(torch.load('tensorboardexp.pt'))
outputs = model(inputs) _, preds = torch.max(outputs.data, 1) 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: return model_ft = models.densenet161(True) num_ftrs = model_ft.classifier.in_features model_ft.classifier = nn.Linear(num_ftrs, 80) if use_gpu: model_ft = nn.DataParallel(model_ft, [0]).cuda() criterion = nn.CrossEntropyLoss() # Observe that all parameters are being optimized optimizer_ft = optim.SGD(model_ft.parameters(), lr=0.001, momentum=0.9) # optimizer_ft = optim.Adam(model_ft.parameters(), lr=0.01) # Decay LR by a factor of 0.1 every 7 epochs exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=2, gamma=0.1)
sort_by="cuda_time_total", row_limit=10)) print( prof.key_averages(group_by_input_shape=True).table( sort_by="cuda_memory_usage", row_limit=10)) prof.export_chrome_trace(filename + '.json') # %% model_zoo = { 'resnet18': models.resnet18(), 'resnet34': models.resnet34(), 'resnet50': models.resnet50(), 'resnet101': models.resnet101(), 'resnet152': models.resnet152(), 'mobilenetv2': models.mobilenet.mobilenet_v2(), 'mobilenetv3_small': models.mobilenet.mobilenet_v3_small(), 'mobilenetv3_large': models.mobilenet.mobilenet_v3_large(), 'densenet161': models.densenet161(), 'densenet201': models.densenet201() } profile_conv_runtimes(models.mobilenet.mobilenet_v3_small(), 'resnet18') # %% model = models.mobilenet.mobilenet_v2() model = model.to(device) print_mobilenet_shapes(model) # shapes = print_resnet_conv_shapes(model) # write_shapes(name, shapes) # %%
def __init__(self, encoder_pretrained=True): super(Encoder, self).__init__() self.densenet = models.densenet161(pretrained=encoder_pretrained) for param in self.densenet.parameters(): param.requires_grad = False
def main(): # To deal with num_workers>1 in DataLoader, which is needed only in Windows environment # https://github.com/pytorch/pytorch/issues/11139 # https://stackoverflow.com/questions/33038209/python-multiprocessing-fails-for-example-code import multiprocessing multiprocessing.freeze_support() data_transforms = { 'train': T.Compose([ T.RandomResizedCrop(224), T.ToTensor(), T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]), 'test': T.Compose([ T.RandomResizedCrop(256), T.CenterCrop(224), T.ToTensor(), T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) } SVHN_path = os.path.join(path, 'mat') SVHN = { x: datasets.SVHN(SVHN_path, split=x, transform=data_transforms[x]) for x in ['train', 'test'] } dataloaders = { x: DataLoader(SVHN[x], batch_size=BS, shuffle=True, num_workers=4) for x in ['train', 'test'] } dataset_sizes = {x: len(SVHN[x]) for x in ['train', 'test']} device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") device = torch.device("cpu") print('Device:', device) # # Get a batch of training data # inputs, classes = next(iter(dataloaders['train'])) # # Make a grid from batch # out = torchvision.utils.make_grid(inputs) # imshow(out, title=[x for x in classes]) ######################## ### Prepare DenseNet ### ######################## densenet = models.densenet161(pretrained=True) num_ftrs = densenet.classifier.in_features densenet.classifier = nn.Linear(num_ftrs, 10) densenet = densenet.to(device) criterion = nn.CrossEntropyLoss() # Observe that all parameters are being optimized optimizer_ft = optim.SGD(densenet.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) densenet = train_model(dataloaders, dataset_sizes, device, densenet, criterion, optimizer_ft, exp_lr_scheduler, num_epochs=1, test=True) torch.save(densenet.state_dict(), os.path.join(path, 'densenet_weights_final.pth'))
def __init__(self, num_hidden): densenet = models.densenet161(pretrained=True) modules = list(densenet.features.children()) annotation_dim = modules[-1].num_features feature_extractor = nn.Sequential(*modules[:-1]) # intermediate feature map: (-1, 2208, 7, 7) super().__init__(feature_extractor, annotation_dim, num_hidden)
def main(train_root, train_csv, val_root, val_csv, test_root, test_csv, epochs, aug, model_name, batch_size, num_workers, val_samples, test_samples, early_stopping_patience, limit_data, images_per_epoch, _run): assert (model_name in ('inceptionv4', 'resnet152', 'densenet161', 'senet154')) AUGMENTED_IMAGES_DIR = os.path.join(fs_observer.dir, 'images') CHECKPOINTS_DIR = os.path.join(fs_observer.dir, 'checkpoints') BEST_MODEL_PATH = os.path.join(CHECKPOINTS_DIR, 'model_best.pth') LAST_MODEL_PATH = os.path.join(CHECKPOINTS_DIR, 'model_last.pth') RESULTS_CSV_PATH = os.path.join('results', 'results.csv') EXP_NAME = _run.meta_info['options']['--name'] EXP_ID = _run._id for directory in (AUGMENTED_IMAGES_DIR, CHECKPOINTS_DIR): os.makedirs(directory) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") if model_name == 'inceptionv4': model = ptm.inceptionv4(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Linear(model.last_linear.in_features, 2) aug['size'] = 299 aug['mean'] = model.mean aug['std'] = model.std elif model_name == 'resnet152': model = models.resnet152(pretrained=True) model.fc = nn.Linear(model.fc.in_features, 2) aug['size'] = 224 aug['mean'] = [0.485, 0.456, 0.406] aug['std'] = [0.229, 0.224, 0.225] elif model_name == 'densenet161': model = models.densenet161(pretrained=True) model.classifier = nn.Linear(model.classifier.in_features, 2) aug['size'] = 224 aug['mean'] = [0.485, 0.456, 0.406] aug['std'] = [0.229, 0.224, 0.225] elif model_name == 'senet154': model = ptm.senet154(num_classes=1000, pretrained='imagenet') model.last_linear = nn.Linear(model.last_linear.in_features, 2) aug['size'] = model.input_size[1] aug['mean'] = model.mean aug['std'] = model.std model.to(device) augs = Augmentations(**aug) model.aug_params = aug datasets = { 'samples': CSVDataset(train_root, train_csv, 'image_id', 'melanoma', transform=augs.tf_augment, add_extension='.jpg', limit=(400, 433)), 'train': CSVDataset(train_root, train_csv, 'image_id', 'melanoma', transform=augs.tf_transform, add_extension='.jpg', random_subset_size=limit_data), 'val': CSVDatasetWithName(val_root, val_csv, 'image_id', 'melanoma', transform=augs.tf_transform, add_extension='.jpg'), 'test': CSVDatasetWithName(test_root, test_csv, 'image_id', 'melanoma', transform=augs.tf_transform, add_extension='.jpg'), 'test_no_aug': CSVDatasetWithName(test_root, test_csv, 'image_id', 'melanoma', transform=augs.no_augmentation, add_extension='.jpg'), 'test_144': CSVDatasetWithName(test_root, test_csv, 'image_id', 'melanoma', transform=augs.inception_crop, add_extension='.jpg'), } dataloaders = { 'train': DataLoader(datasets['train'], batch_size=batch_size, shuffle=True, num_workers=num_workers, worker_init_fn=set_seeds), 'samples': DataLoader(datasets['samples'], batch_size=batch_size, shuffle=False, num_workers=num_workers, worker_init_fn=set_seeds), } save_images(datasets['samples'], to=AUGMENTED_IMAGES_DIR, n=32) sample_batch, _ = next(iter(dataloaders['samples'])) save_image(make_grid(sample_batch, padding=0), os.path.join(AUGMENTED_IMAGES_DIR, 'grid.jpg')) criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9, weight_decay=0.001) scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=[10], gamma=0.1) metrics = { 'train': pd.DataFrame(columns=['epoch', 'loss', 'acc', 'auc']), 'val': pd.DataFrame(columns=['epoch', 'loss', 'acc', 'auc']) } best_val_auc = 0.0 best_epoch = 0 epochs_without_improvement = 0 if images_per_epoch: batches_per_epoch = images_per_epoch // batch_size else: batches_per_epoch = None for epoch in range(epochs): print('train epoch {}/{}'.format(epoch + 1, epochs)) epoch_train_result = train_epoch(device, model, dataloaders, criterion, optimizer, batches_per_epoch) metrics['train'] = metrics['train'].append( { **epoch_train_result, 'epoch': epoch }, ignore_index=True) print('train', epoch_train_result) epoch_val_result, _ = test_with_augmentation(model, datasets['val'], device, num_workers, val_samples) metrics['val'] = metrics['val'].append( { **epoch_val_result, 'epoch': epoch }, ignore_index=True) print('val', epoch_val_result) print('-' * 40) scheduler.step() if epoch_val_result['auc'] > best_val_auc: best_val_auc = epoch_val_result['auc'] best_epoch = epoch epochs_without_improvement = 0 torch.save(model, BEST_MODEL_PATH) else: epochs_without_improvement += 1 if epochs_without_improvement > early_stopping_patience: torch.save(model, LAST_MODEL_PATH) break if epoch == (epochs - 1): torch.save(model, LAST_MODEL_PATH) for phase in ['train', 'val']: metrics[phase].epoch = metrics[phase].epoch.astype(int) metrics[phase].to_csv(os.path.join(fs_observer.dir, phase + '.csv'), index=False) # Run testing test_result, _ = test_with_augmentation(torch.load(BEST_MODEL_PATH), datasets['test'], device, num_workers, test_samples) print('test', test_result) test_noaug_result, _ = test_with_augmentation(torch.load(BEST_MODEL_PATH), datasets['test_no_aug'], device, num_workers, 1) print('test (no augmentation)', test_noaug_result) test_144crop_result, _ = test_with_augmentation( torch.load(BEST_MODEL_PATH), datasets['test_144'], device, num_workers, 1) print('test (144-crop)', test_144crop_result) with open(RESULTS_CSV_PATH, 'a') as file: file.write(','.join((EXP_NAME, str(EXP_ID), str(best_epoch), str(best_val_auc), str(test_noaug_result['auc']), str(test_result['auc']), str(test_144crop_result['auc']))) + '\n') return (test_noaug_result['auc'], test_result['auc'], test_144crop_result['auc'])
_, pred = output.topk(maxk, 1, True, True) pred = pred.t() correct = pred.eq(target.view(1, -1).expand_as(pred)) res = [] for k in topk: correct_k = correct[:k].view(-1).float().sum(0, keepdim=True) res.append(correct_k.mul_(100.0 / batch_size)) return res NAME_TO_MODEL = { 'resnet50': resnet50(num_classes=100), 'ayangnet': AyangNet(), 'densenet': models.densenet161(num_classes=100), 'inceptionv3': inception_v3(num_classes=100), 'inceptionv4': inception_v4(num_classes=100), 'wideresnet': WideResNet(28, 100, widen_factor=10), 'widedensenet': DenseNet(60, (6, 6, 6, 6), 64, num_classes=100) } if __name__ == '__main__': default_path = './preprocess' noise_decay = 0.55 loss_fn = CrossEntropyLoss() # set up argument parser parser = argparse.ArgumentParser() # experiment
def get_model(model_id, use_pretrained): model_ft = None if model_id == PyTorchModelsEnum.ALEXNET: model_ft = models.alexnet(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.DENSENET121: model_ft = models.densenet121(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.DENSENET161: model_ft = models.densenet161(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.DENSENET169: model_ft = models.densenet169(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.DENSENET201: model_ft = models.densenet201(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.GOOGLENET: model_ft = models.googlenet(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.INCEPTION_V3: model_ft = models.inception_v3(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.MOBILENET_V2: model_ft = models.mobilenet_v2(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.MNASNET_0_5: model_ft = models.mnasnet0_5(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.MNASNET_0_75: # no pretrained model_ft = models.mnasnet0_75(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.MNASNET_1_0: model_ft = models.mnasnet1_0(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.MNASNET_1_3: model_ft = models.mnasnet1_3(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.RESNET18: model_ft = models.resnet18(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.RESNET34: model_ft = models.resnet34(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.RESNET50: model_ft = models.resnet50(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.RESNET101: model_ft = models.resnet101(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.RESNET152: model_ft = models.resnet152(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.RESNEXT50: model_ft = models.resnext50_32x4d(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.RESNEXT101: model_ft = models.resnext101_32x8d(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.SHUFFLENET_V2_0_5: model_ft = models.shufflenet_v2_x0_5(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.SHUFFLENET_V2_1_0: model_ft = models.shufflenet_v2_x1_0(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.SHUFFLENET_V2_1_5: model_ft = models.shufflenet_v2_x1_5(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.SHUFFLENET_V2_2_0: model_ft = models.shufflenet_v2_x2_0(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.SQUEEZENET1_0: model_ft = models.squeezenet1_0(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.SQUEEZENET1_1: model_ft = models.squeezenet1_1(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.VGG11: model_ft = models.vgg11(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.VGG11_BN: model_ft = models.vgg11_bn(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.VGG13: model_ft = models.vgg13(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.VGG13_BN: model_ft = models.vgg13_bn(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.VGG16: model_ft = models.vgg16(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.VGG16_BN: model_ft = models.vgg16_bn(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.VGG19: model_ft = models.vgg19(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.VGG19_BN: model_ft = models.vgg19_bn(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.WIDE_RESNET50: model_ft = models.wide_resnet50_2(pretrained=use_pretrained) elif model_id == PyTorchModelsEnum.WIDE_RESNET101: model_ft = models.wide_resnet101_2(pretrained=use_pretrained) return model_ft
print('LR is set to {}'.format(lr)) optimizer.param_groups[0]['lr'] = lr optimizer.param_groups[1]['lr'] = lr * 10 return optimizer ###################################################################### # Finetuning the convnet # ---------------------- # # Load a pretrained model and reset final fully connected layer. # model_ft = models.densenet161(pretrained=True, drop_rate=0.5) num_ftrs = model_ft.classifier.in_features model_ft.classifier = nn.Linear(num_ftrs, n_classes) model_ft.max_num = 2 if use_gpu: model_ft = model_ft.cuda() criterion = nn.CrossEntropyLoss() # Observe that all parameters are being optimized # Observe that all parameters are being optimized ignored_params = list(map(id, model_ft.classifier.parameters())) base_params = filter(lambda p: id(p) not in ignored_params, model_ft.parameters())
return optimizer ### SECTION 3 : DEFINING MODEL ARCHITECTURE. # Set the pre-trained model in the ocnfig file by MODEL_FT. if MODEL_FT == 'inception_v3': model_ft = models.inception_v3(pretrained=IS_PRETRAINED) elif MODEL_FT == 'resnet18': model_ft = models.resnet18(pretrained=IS_PRETRAINED) elif MODEL_FT == 'resnet152': model_ft = models.resnet152(pretrained=IS_PRETRAINED) elif MODEL_FT == 'vgg16': model_ft = models.vgg16(pretrained=IS_PRETRAINED) elif MODEL_FT == 'densenet': model_ft = models.densenet161(pretrained=IS_PRETRAINED) elif MODEL_FT == 'alexnet': model_ft = models.alexnet(pretrained=IS_PRETRAINED) else: model_ft = None print("Error from FT Config Setting! Invalid Pretrained Model Name Value!") # Set model parameters if 'vgg' in MODEL_FT or 'alexnet' in MODEL_FT: num_ftrs = model_ft.classifier[6].in_features features = list(model_ft.classifier.children())[:-1] features.apppend([nn.Linear(num_ftrs, NUM_CLASSES)]) model_ft.classifier = nn.Sequential(*features) elif 'densenet' in MODEL_FT: num_ftrs = model_ft.classifier.in_features
def __init__(self, num_classes, num_channels=3, is_deconv=False, decoder_kernel_size=4, pretrained=True): super().__init__() filters = [384, 768, 2112, 2208] densenet = models.densenet161(pretrained=pretrained) self.mean = (0.485, 0.456, 0.406) self.std = (0.229, 0.224, 0.225) if num_channels == 3: self.firstconv = densenet.features.conv0 else: self.firstconv = nn.Conv2d(num_channels, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3)) self.stem = nn.Sequential( self.firstconv, densenet.features.norm0, densenet.features.relu0, densenet.features.pool0, ) self.encoder1 = nn.Sequential(densenet.features.denseblock1) self.encoder2 = nn.Sequential(densenet.features.transition1, densenet.features.denseblock2) self.encoder3 = nn.Sequential(densenet.features.transition2, densenet.features.denseblock3) self.encoder4 = nn.Sequential(densenet.features.transition3, densenet.features.denseblock4) # Decoder self.decoder4 = DecoderBlock(in_channels=filters[3], n_filters=filters[2], kernel_size=decoder_kernel_size, is_deconv=is_deconv) self.decoder3 = DecoderBlock(in_channels=filters[2], n_filters=filters[1], kernel_size=decoder_kernel_size, is_deconv=is_deconv) self.decoder2 = DecoderBlock(in_channels=filters[1], n_filters=filters[0], kernel_size=decoder_kernel_size, is_deconv=is_deconv) self.decoder1 = DecoderBlock(in_channels=filters[0], n_filters=filters[0], kernel_size=decoder_kernel_size, is_deconv=is_deconv) # Final Classifier self.finaldeconv1 = nn.ConvTranspose2d(filters[0], 32, 3, stride=2) self.finalrelu1 = nonlinearity(inplace=True) self.finalconv2 = nn.Conv2d(32, 32, 3) self.finalrelu2 = nonlinearity(inplace=True) self.finalconv3 = nn.Conv2d(32, num_classes, 2, padding=1)
def main(): parser = argparse.ArgumentParser(description='train DSH') parser.add_argument('--cifar', default='../dataset/cifar', help='path to cifar') parser.add_argument('--weights', default='', help="path to weight (to continue training)") parser.add_argument('--outf', default='checkpoints', help='folder to output model checkpoints') parser.add_argument('--checkpoint', type=int, default=2, help='checkpointing after batches') parser.add_argument('--batchSize', type=int, default=4, help='input batch size') parser.add_argument('--ngpu', type=int, default=0, help='which GPU to use') parser.add_argument('--binary_bits', type=int, default=12, help='length of hashing binary') parser.add_argument('--alpha', type=float, default=0.01, help='weighting of regularizer') parser.add_argument('--niter', type=int, default=2, help='number of epochs to train for') parser.add_argument('--lr', type=float, default=0.001, help='learning rate') opt = parser.parse_args() print(opt) os.makedirs(opt.outf, exist_ok=True) choose_gpu(opt.ngpu) feed_random_seed() train_loader, test_loader = init_cifar_dataloader(opt.cifar, opt.batchSize) logger = SummaryWriter() densenet161 = models.densenet161(pretrained=True) #vgg19_bn_model = models.vgg19_bn(pretrained=True) #print(model) for param in densenet161.parameters(): param.requires_grad = False num_ftrs = densenet161.classifier.in_features # five classes Output_features = opt.binary_bits densenet161.classifier.out_features = Output_features for param in densenet161.classifier.parameters(): param.requires_grad = True net = torch.nn.DataParallel(densenet161).cuda() # setup net # net = DSH(opt.binary_bits) resume_epoch = 0 print(net) if opt.weights: print(f'loading weight form {opt.weights}') resume_epoch = int(os.path.basename(opt.weights)[:-4]) net.load_state_dict( torch.load(opt.weights, map_location=lambda storage, location: storage)) # setup optimizer # optimizer = optim.Adam(net.parameters(), lr=opt.lr, weight_decay=0.004) optimizer = optim.SGD(net.module.classifier.parameters(), lr=1e-3, weight_decay=1e-4, momentum=0.9) for epoch in range(resume_epoch, opt.niter): train_loss = train(epoch, train_loader, net, optimizer, 2 * opt.binary_bits, opt.alpha) logger.add_scalar('train_loss', train_loss, epoch) test_loss = test(epoch, test_loader, net, 2 * opt.binary_bits, opt.alpha) logger.add_scalar('test_loss', test_loss, epoch) if epoch % opt.checkpoint == 0: # compute mAP by searching testset images from trainset trn_binary, trn_label = compute_result(train_loader, net) tst_binary, tst_label = compute_result(test_loader, net) #mAP = compute_mAP(trn_binary, tst_binary, trn_label, tst_label) #print(f'[{epoch}] retrieval mAP: {mAP:.4f}') #logger.add_scalar('retrieval_mAP', mAP, epoch) # change the learning rate optimizer = optim.SGD(net.module.classifier.parameters(), lr=((1e-3) - epoch * (1e-4)), weight_decay=1e-4, momentum=0.9) print((1e-3) - epoch * (1e-4)) # save checkpoints torch.save(net.state_dict(), os.path.join(opt.outf, f'{epoch:03d}.pth'))
def __init__(self, num_classes): super(DenseNet161, self).__init__() self.name = "DenseNet_{}".format(161) densenet = torch_model.densenet161() self.features = densenet.features self.fc = nn.Linear(densenet.classifier.in_features, num_classes)
def load_checkpoint(filepath,input_device): checkpoint = torch.load(filepath) print('') print('===============') print('checkpoint:') print(checkpoint['model_name']) print(checkpoint['model_classifier']) print('') if (checkpoint['model_name']=='resnet152'): model = models.resnet152(pretrained=True) for param in model.parameters(): param.requires_grad = False #model=checkpoint['model_base'] model.class_to_idx=checkpoint['class_to_label'] model.fc = checkpoint['model_classifier'] model.load_state_dict(checkpoint['model_state_dict']) elif (checkpoint['model_name']=='alexnet'): model = models.alexnet(pretrained=True) for param in model.parameters(): param.requires_grad = False model.class_to_idx=checkpoint['class_to_label'] model.classifier = checkpoint['model_classifier'] model.load_state_dict(checkpoint['model_state_dict']) elif (checkpoint['model_name']=='densenet161'): model = models.densenet161(pretrained=True) for param in model.parameters(): param.requires_grad = False model.class_to_idx=checkpoint['class_to_label'] model.classifier = checkpoint['model_classifier'] model.load_state_dict(checkpoint['model_state_dict']) else: print('!!!!Prediction module supports only resnet152, densenet161, and alexnet checkpoint!!!!') print('') print('') if(input_device=='cuda'): model=model.cuda() if(input_device=='cpu'): model=model.cpu() # model=model.cuda() model=model.eval() return model,checkpoint,input_device
checkpoint = torch.load(pretrained_path) self.encoder.load_state_dict(checkpoint) def forward(self, x): self.features = [] out = self.encoder.features.conv0(x) out = self.encoder.features.norm0(out) out = self.encoder.features.relu0(out) self.features.append(out) # 1/2 out = self.encoder.features.pool0(out) self.features.append(out) # 1/4 out = self.encoder.features.transition1(self.encoder.features.denseblock1(out)) self.features.append(out) # 1/8 out = self.encoder.features.transition2(self.encoder.features.denseblock2(out)) self.features.append(out) # 1/16 out = self.encoder.features.transition3(self.encoder.features.denseblock3(out)) out = self.encoder.features.norm5(self.encoder.features.denseblock4(out)) out = F.relu(out) return out, self.features if __name__ == "__main__": import torchvision.models as models model = models.densenet161(True)
models = { "alexnet": { "model": models.alexnet(pretrained=True), "path": "both" }, "vgg16": { "model": models.vgg16(pretrained=True), "path": "both" }, "squeezenet": { "model": models.squeezenet1_0(pretrained=True), "path": "both" }, "densenet": { "model": models.densenet161(pretrained=True), "path": "both" }, "inception_v3": { "model": models.inception_v3(pretrained=True), "path": "both" }, #"googlenet": models.googlenet(pretrained=True), "shufflenet": { "model": models.shufflenet_v2_x1_0(pretrained=True), "path": "both" }, "mobilenet_v2": { "model": models.mobilenet_v2(pretrained=True), "path": "both" },
import pdb # input image LABELS_URL = 'https://s3.amazonaws.com/outcome-blog/imagenet/labels.json' IMG_URL = 'http://media.mlive.com/news_impact/photo/9933031-large.jpg' # networks such as googlenet, resnet, densenet already use global average pooling at the end, so CAM could be used directly. model_id = 1 if model_id == 1: net = models.squeezenet1_1(pretrained=True) finalconv_name = 'features' # this is the last conv layer of the network elif model_id == 2: net = models.resnet18(pretrained=True) finalconv_name = 'layer4' elif model_id == 3: net = models.densenet161(pretrained=True) finalconv_name = 'features' net.eval() # hook the feature extractor features_blobs = [] def hook_feature(module, input, output): features_blobs.append(output.data.cpu().numpy()) net._modules.get(finalconv_name).register_forward_hook(hook_feature) # get the softmax weight params = list(net.parameters()) weight_softmax = np.squeeze(params[-2].data.numpy())
def CAM(self): # simple implementation of CAM in PyTorch for the networks such as ResNet, DenseNet, SqueezeNet, Inception import io import requests from PIL import Image from torchvision import models, transforms from torch.autograd import Variable from torch.nn import functional as F import numpy as np import cv2 import pdb # input image LABELS_URL = 'https://s3.amazonaws.com/outcome-blog/imagenet/labels.json' IMG_URL = 'http://media.mlive.com/news_impact/photo/9933031-large.jpg' # networks such as googlenet, resnet, densenet already use global average pooling at the end, so CAM could be used directly. model_id = 1 if model_id == 1: net = models.squeezenet1_1(pretrained=True) finalconv_name = 'features' # this is the last conv layer of the network elif model_id == 2: net = models.resnet18(pretrained=True) finalconv_name = 'layer4' elif model_id == 3: net = models.densenet161(pretrained=True) finalconv_name = 'features' net.eval() # hook the feature extractor features_blobs = [] def hook_feature(module, input, output): features_blobs.append(output.data.cpu().numpy()) net._modules.get(finalconv_name).register_forward_hook(hook_feature) # get the softmax weight params = list(net.parameters()) weight_softmax = np.squeeze(params[-2].data.numpy()) def returnCAM(feature_conv, weight_softmax, class_idx): # generate the class activation maps upsample to 256x256 size_upsample = (256, 256) bz, nc, h, w = feature_conv.shape output_cam = [] for idx in class_idx: cam = weight_softmax[idx].dot(feature_conv.reshape((nc, h * w))) cam = cam.reshape(h, w) cam = cam - np.min(cam) cam_img = cam / np.max(cam) cam_img = np.uint8(255 * cam_img) output_cam.append(cv2.resize(cam_img, size_upsample)) return output_cam normalize = transforms.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225] ) preprocess = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), normalize ]) response = requests.get(IMG_URL) img_pil = Image.open(io.BytesIO(response.content)) img_pil.save('test.jpg') img_tensor = preprocess(img_pil) img_variable = Variable(img_tensor.unsqueeze(0)) logit = net(img_variable) # download the imagenet category list classes = {int(key): value for (key, value) in requests.get(LABELS_URL).json().items()} h_x = F.softmax(logit, dim=1).data.squeeze() probs, idx = h_x.sort(0, True) probs = probs.numpy() idx = idx.numpy() # output the prediction for i in range(0, 5): print('{:.3f} -> {}'.format(probs[i], classes[idx[i]])) # generate class activation mapping for the top1 prediction CAMs = returnCAM(features_blobs[0], weight_softmax, [idx[0]]) # render the CAM and output print('output CAM.jpg for the top1 prediction: %s' % classes[idx[0]]) img = cv2.imread('test.jpg') height, width, _ = img.shape heatmap = cv2.applyColorMap(cv2.resize(CAMs[0], (width, height)), cv2.COLORMAP_JET) result = heatmap * 0.3 + img * 0.5 cv2.imwrite('CAM.jpg', result)
def dn161(pre): return children(densenet161(pre))[0] @_fastai_model('Densenet-161', 'Densely Connected Convolutional Networks',
def dn161(pre): return children(densenet161(pre))[0] def dn169(pre): return children(densenet169(pre))[0]