def load_model_by_state(file, arch): """ Load the stored model from storage. Args: file (string): The path to the checkpoint (saved model status). arch (string): The name (archited name) or the pretrained model. Returns: model: the pretrained model with our newly trainning states. """ if arch == 'vgg11': model = models.vgg11(pretrained=True) elif arch == 'vgg13': model = models.vgg13(pretrained=True) elif arch == 'vgg19': model = models.vgg19(pretrained=True) elif arch == 'mnasanet': model = models.mnasnet0_5(pretrained=True) else: model = model = models.vgg16(pretrained=True) model_state = torch.load(file, map_location=lambda storage, loc: storage) model.classifier = model_state['classifier'] model.load_state_dict(model_state['state_dict']) model.class_to_idx = model_state['class_to_idx'] print("Load stored model successfully: ", file) return model
def main(): ONNX_SAVE_ROOT.mkdir(parents=True, exist_ok=True) # VGG11_bn (2.11ms) # gen_onnx(models.vgg11_bn().features, "VGG11_bn") # ResNet18 (0.86ms) gen_onnx(models.resnet18(pretrained=True), "ResNet18") # Densenet121 (5.2ms) # gen_onnx(models.densenet121(), "Densenet121") # shufflenet v2 x1.0 (0.87ms) gen_onnx(models.shufflenet_v2_x1_0(pretrained=True), "ShuffleNetV2_x1.0") """ # hard sigmoid 미지원 # MobileNet V3 Large gen_onnx(models.mobilenet_v3_large(), "MobileNetV3_large") # MobileNet V3 Small gen_onnx(models.mobilenet_v3_small(), "MobileNetV3_small") """ # ResNeXt-50-32x4d (3.15ms) # gen_onnx(models.resnext50_32x4d(), "ResNeXt50_32x4d") # Wide ResNet-50-2 (3.37ms) # gen_onnx(models.wide_resnet50_2(), "WideResNet_50_2") # MNASNet 1.0 (0.99ms) gen_onnx(models.mnasnet1_0(pretrained=True), "MNASNet_1_0") # MNASNet 0.5 (0.6ms) gen_onnx(models.mnasnet0_5(pretrained=True), "MNASNet_0_5")
def eval(model_name: str) -> None: if model_name == "mnasnet0_5": model = models.mnasnet0_5(num_classes=1000, pretrained=True).cuda() elif model_name == "mnasnet0_75": model = models.mnasnet0_75(num_classes=1000).cuda() elif model_name == "mnasnet1_0": model = models.mnasnet1_0(num_classes=1000, pretrained=True).cuda() elif model_name == "mnasnet1_3": model = models.mnasnet1_3(num_classes=1000).cuda() else: raise ValueError("Don't know how to evaluate {}".format(model_name)) loss = torch.nn.CrossEntropyLoss().cuda() val_dataset = imagenet.validation(IMAGENET_DIR) val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=512, shuffle=False, num_workers=8, pin_memory=True) all_metrics = metrics.default() model.eval() with torch.no_grad(): val_losses = [] metric_dict = collections.defaultdict(list) for batch_index, (inputs, truth) in enumerate(tqdm.tqdm(val_loader)): outputs = model(inputs.cuda()).cpu() val_losses.append(loss(outputs, truth).item()) for name, metric_fn in all_metrics: metric_dict[name].append(metric_fn(outputs, truth)) print( numpy.mean(val_losses), list([(name, numpy.mean(vals)) for name, vals in metric_dict.items()]))
def mnasnet0_5(pretrained: bool, progress: bool = True, requires_grad: bool = True): model = models.mnasnet0_5(pretrained=pretrained, progress=progress) for params in model.parameters(): params.requires_grad = requires_grad return model
def mnasnet(layer, use_gpu, pretrained): model = models.mnasnet0_5(pretrained=pretrained) # print(model) # use_gpu = False for parma in model.parameters(): parma.requires_grad = False # model.avgpool = torch.nn.AdaptiveAvgPool2d((7,7)) model.layers[0] = torch.nn.Sequential( torch.nn.Conv2d(layer, 16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)) model.classifier = torch.nn.Sequential( torch.nn.Dropout(p=0.2, inplace=True), torch.nn.Linear(in_features=1280, out_features=3, bias=True)) # for indexf,parmaf in enumerate(model.layers[0].parameters()): # if indexf == 0: # parmaf.requires_grad = True # for index, parma in enumerate(model.classifier.parameters()): # if index == 1: # parma.requires_grad = True if use_gpu: # if torch.cuda.device_count()>1: # model = nn.DataParallel(model) model = model.cuda() return model
def get_mnasnet0_5(class_num): model = models.mnasnet0_5(pretrained=True) set_parameter_requires_grad(model) model.name = 'mnasnet0_5' n_inputs = model.classifier[1].in_features model.classifier[1] = nn.Linear(n_inputs, class_num) return model, 224
def mnasnet_0_5_nc_1k(): m = mnasnet0_5(pretrained=True, progress=False) m.classifier = nn.Sequential() # ditch the FC layer del m.layers[14:] for p in m.parameters(): p.requires_grad_(False) for p in m.layers[13].parameters(): p.requires_grad_(True) m.layers.add_module('14', nn.Conv2d(160, 1000, kernel_size=(1, 1), stride=(1, 1), bias=True)) return m
def train(model_name: str) -> None: if model_name == "mnasnet0_5": model = models.mnasnet0_5(num_classes=1000).cuda() elif model_name == "mnasnet0_75": model = models.mnasnet0_75(num_classes=1000).cuda() elif model_name == "mnasnet1_0": model = models.mnasnet1_0(num_classes=1000).cuda() elif model_name == "mnasnet1_3": model = models.mnasnet1_3(num_classes=1000).cuda() else: raise ValueError("Don't know how to train {}".format(model_name)) params = TRAINING_PARAMS[model_name] if torch.cuda.device_count() > 1: model = torch.nn.DataParallel(model) optimizer = torch.optim.SGD(model.parameters(), lr=params["base_lr"], momentum=params["momentum"], weight_decay=params["weight_decay"], nesterov=True) loss = torch.nn.CrossEntropyLoss().cuda() lr_schedule = CosineWithWarmup(optimizer, WARMUP, 0.1, params["num_epochs"]) train_dataset = imagenet.training(IMAGENET_DIR) val_dataset = imagenet.validation(IMAGENET_DIR) message = "Training {}, cosine annealing with warmup. Parameters: {}".format( model_name, params) train = trainer.Trainer(".", message, "multiclass_classification", True, model, optimizer, loss, lr_schedule, metrics.default(), cudnn_autotune=True) train.fit(train_dataset, val_dataset, num_epochs=params["num_epochs"], batch_size=params["batch_size"], num_workers=multiprocessing.cpu_count())
def main(): parser = argparse.ArgumentParser(description='Process args for Triplet Net Training') parser.add_argument("--val_dir", type=str, help="Val directory", default="/home/delta_one/Metric_Learning/tiny-imagenet-200/val") parser.add_argument("--val_annotation_file", type=str, help="Val Annotation File", default="/home/delta_one/Metric_Learning/tiny-imagenet-200/val/val_annotations.txt") parser.add_argument('--classes', type=str, nargs='+', default=\ ['n01443537', 'n01629819', 'n01641577', 'n01644900', 'n01698640', 'n01742172', 'n01768244', 'n01770393', 'n01774384', 'n01774750'], help='Classes used for Train and Eval') parser.add_argument('--samples_per_class', type=int, default=50, help='# Samples used for Test') parser.add_argument('--batch_size_test', type=int, default=30, help='validation set input batch size') args = parser.parse_args() transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) val_dataset = TinyImagnet_Val(root_dir=args.val_dir, transform=transform_test, annotation_file=args.val_annotation_file, given_classes=args.classes, samples_per_class=args.samples_per_class) nw = 4 if torch.cuda.is_available() else 0 val_dataloader = DataLoader(val_dataset, batch_size=args.batch_size_test, num_workers=nw, shuffle=False) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") writer = SummaryWriter(log_dir="logs/") model_dict = { "AlexNet": models.alexnet(pretrained=True), "DenseNet": models.densenet121(pretrained=True), "MNASNet": models.mnasnet0_5(pretrained=True), "MobileNetV2": models.mobilenet_v2(pretrained=True), "ResNet18": models.resnet18(pretrained=True), "ResNet101": models.resnet101(pretrained=True), "ShuffleNet": models.shufflenet_v2_x0_5(pretrained=True), "SqueezeNet": models.squeezenet1_0(pretrained=True), "VGG19": models.vgg19(pretrained=True) } test(val_dataloader, model_dict, writer, device)
def main(train_loader, train_datasets, valid_loader): '''args: model_arch, train_loader, train_datasets, valid_loader, epochs, learning_rate, hidden_units, device, save_dir saves checkpoint under save_dir returns: checkpoint with {'epoch_tot', 'model', 'criterion', 'optimizer', 'optimizer.state_dict', 'model.state_dict', 'model.class_to_idx'}''' arg = input_args() model_arch = arg.arch hidden_units = arg.hidden_units learning_rate = arg.learning_rate device = arg.device epochs = arg.epochs save_dir = arg.save_dir if model_arch == 'alexnet': gs_vgg = models.alexnet(pretrained=True) elif model_arch == 'vgg11': gs_vgg = models.vgg11(pretrained=True) elif model_arch == 'vgg11_bn': gs_vgg = models.vgg11_bn(pretrained=True) elif model_arch == 'vgg13': gs_vgg = models.vgg13(pretrained=True) elif model_arch == 'vgg13_bn': gs_vgg = models.vgg13_bn(pretrained=True) elif model_arch == 'vgg16': gs_vgg = models.vgg16(pretrained=True) elif model_arch == 'vgg16_bn': gs_vgg = models.vgg16_bn(pretrained=True) elif model_arch == 'vgg19': gs_vgg = models.vgg19(pretrained=True) elif model_arch == 'vgg19_bn': gs_vgg = models.vgg19_bn(pretrained=True) elif model_arch == 'resnet18': gs_vgg = models.resnet18(pretrained=True) elif model_arch == 'resnet34': gs_vgg = models.resnet34(pretrained=True) elif model_arch == 'resnet50': gs_vgg = models.resnet50(pretrained=True) elif model_arch == 'resnet101': gs_vgg = models.resnet101(pretrained=True) elif model_arch == 'resnet152': gs_vgg = models.resnet152(pretrained=True) elif model_arch == 'squeezenet1_0': gs_vgg = models.squeezenet1_0(pretrained=True) elif model_arch == 'squeezenet1_1': gs_vgg = models.squeezenet1_1(pretrained=True) elif model_arch == 'densenet121': gs_vgg = models.densenet121(pretrained=True) elif model_arch == 'densenet169': gs_vgg = models.densenet169(pretrained=True) elif model_arch == 'densenet161': gs_vgg = models.densenet161(pretrained=True) elif model_arch == 'densenet201': gs_vgg = models.densenet201(pretrained=True) elif model_arch == 'inception_v3': gs_vgg = models.inception_v3(pretrained=True) elif model_arch == 'googlenet': gs_vgg = models.googlenet(pretrained=True) elif model_arch == 'shufflenet_v2_x0_5': gs_vgg = models.shufflenet_v2_x0_5(pretrained=True) elif model_arch == 'shufflenet_v2_x1_0': gs_vgg = models.shufflenet_v2_x1_0(pretrained=True) elif model_arch == 'shufflenet_v2_x1_5': gs_vgg = models.shufflenet_v2_x1_5(pretrained=True) elif model_arch == 'shufflenet_v2_x2_0': gs_vgg = models.shufflenet_v2_x2_0(pretrained=True) elif model_arch == 'mobilenet_v2': gs_vgg = models.mobilenet_v2(pretrained=True) elif model_arch == 'resnext50_32x4d': gs_vgg = models.resnext50_32x4d(pretrained=True) elif model_arch == 'resnext101_32x8d': gs_vgg = models.resnext101_32x8d(pretrained=True) elif model_arch == 'wide_resnet50_2': gs_vgg = models.wide_resnet50_2(pretrained=True) elif model_arch == 'wide_resnet101_2': gs_vgg = models.wide_resnet101_2(pretrained=True) elif model_arch == 'mnasnet0_5': gs_vgg = models.mnasnet0_5(pretrained=True) elif model_arch == 'mnasnet0_75': gs_vgg = models.mnasnet0_75(pretrained=True) elif model_arch == 'mnasnet1_0': gs_vgg = models.mnasnet1_0(pretrained=True) elif model_arch == 'mnasnet1_3': gs_vgg = models.mnasnet1_3(pretrained=True) epoch_tot = 0 for parameters in gs_vgg.parameters(): parameters.requires_grad = False try: input_layer = gs_vgg.classifier[0].in_features except: input_layer = gs_vgg.classifier.in_features hidden_layers = [(int(hidden_units * 0.68)), (int(hidden_units * 0.32))] output_layer = len(train_loader) gs_vgg.classifier = nn.Sequential( nn.Linear(input_layer, hidden_layers[0]), nn.ReLU(), nn.Dropout(p=0.3), nn.Linear(hidden_layers[0], hidden_layers[1]), nn.ReLU(), #nn.Linear(hidden_layers[1], output_layer), nn.Linear(hidden_layers[1], 102), nn.LogSoftmax(dim=1)) criterion = nn.NLLLoss() optimizer = optim.Adam(gs_vgg.classifier.parameters(), lr=learning_rate) gs_vgg.to(device) step_num = 0 epoch = epochs running_loss = 0 print_every = 10 for e in range(epoch): epoch_tot += 1 for images, labels in train_loader: gs_vgg.train() images, labels = images.to(device), labels.to(device) optimizer.zero_grad() output = gs_vgg.forward(images) loss = criterion(output, labels) loss.backward() optimizer.step() running_loss += loss.item() step_num += 1 if step_num % print_every == 0: test_loss = 0 accuracy = 0 gs_vgg.eval() for images, labels in valid_loader: images, labels = images.to(device), labels.to(device) output = gs_vgg.forward(images) loss = criterion(output, labels) test_loss += loss.item() prob = torch.exp(output) top_p, top_class = prob.topk(1, dim=1) equals = top_class == labels.view(*top_class.shape) accuracy += torch.mean(equals.type( torch.FloatTensor)).item() print( f"Total Epochs: {epoch_tot}.. " f"Train loss: {running_loss/print_every:.3f}.. " f"Test loss: {test_loss/len(valid_loader):.3f}.. " f"Test accuracy: {(accuracy/len(valid_loader))*100:.1f}%") running_loss = 0 gs_vgg.train() gs_vgg.class_to_idx = train_datasets.class_to_idx gs_checkpoint = { 'epoch_tot': epoch_tot, 'model': gs_vgg, 'criterion': criterion, 'optimizer': optimizer, 'optimizer.state_dict': optimizer.state_dict(), 'model.state_dict': gs_vgg.state_dict(), 'model.class_to_idx': gs_vgg.class_to_idx } torch.save(gs_checkpoint, save_dir) return gs_checkpoint
def __init__(self): super(GoNet, self).__init__() #CHOSE THE PRETRAINED MODEL YOU WANT TO USE (UNCOMMENT IT) #caffenet = models.alexnet(pretrained=True) #(256*6*6) #caffenet = models.vgg16(pretrained=True) #(7*7*512) #caffenet = models.shufflenet_v2_x0_5(pretrained=True) #(1024*7*7) #caffenet = models.mobilenet_v2(pretrained=True) # (7*7*1280) caffenet = models.mnasnet0_5(pretrained=True) #( 7*7*1280) #caffenet = models.resnet18(pretrained = True) #(512*2) #caffenet = models.resnet50(pretrained = True) #(1024) self.convnet = nn.Sequential(*list(caffenet.children())[:-1]) for param in self.convnet.parameters(): param.requires_grad = False """ #USED WITH CORRELATION OF TWO IMAGES caffenetcorr = models.alexnet(pretrained=False) self.convnetcorr = nn.Sequential(*list(caffenetcorr.children())[:-1]) for param in self.convnetcorr.parameters(): param.requires_grad = True """ """ #### GROUP CONNECTED LAYER size_input = 7*7*1280*2 self.layer10 = nn.Linear(math.ceil(size_input/20), 205, bias=True) self.layer11 = nn.Linear(math.ceil(size_input/20), 205, bias=True) self.layer12 = nn.Linear(math.ceil(size_input/20), 205, bias=True) self.layer13 = nn.Linear(math.ceil(size_input/20), 205, bias=True) self.layer14 = nn.Linear(math.ceil(size_input/20), 205, bias=True) self.layer15 = nn.Linear(math.ceil(size_input/20), 205, bias=True) self.layer16 = nn.Linear(math.ceil(size_input/20), 205, bias=True) self.layer17 = nn.Linear(math.ceil(size_input/20), 205, bias=True) self.layer18 = nn.Linear(math.ceil(size_input/20), 205, bias=True) self.layer19 = nn.Linear(math.ceil(size_input/20), 205, bias=True) self.layer110 = nn.Linear(math.ceil(size_input/20), 205, bias=True) self.layer111 = nn.Linear(math.ceil(size_input/20), 205, bias=True) self.layer112 = nn.Linear(math.ceil(size_input/20), 205, bias=True) self.layer113 = nn.Linear(math.ceil(size_input/20), 205, bias=True) self.layer114 = nn.Linear(math.ceil(size_input/20), 205, bias=True) self.layer115 = nn.Linear(math.ceil(size_input/20), 205, bias=True) self.layer116 = nn.Linear(math.ceil(size_input/20), 204, bias=True) self.layer117 = nn.Linear(math.ceil(size_input/20), 204, bias=True) self.layer118 = nn.Linear(math.ceil(size_input/20), 204, bias=True) self.layer119 = nn.Linear(math.ceil(size_input/20), 204, bias=True) self.classifier = nn.Sequential( #nn.Linear(256*6*6*2, 4096), #nn.Linear(256*6*6*2, 4096), # #nn.Linear(512*7*7*2, 4096), # #nn.Linear(1280*7*7*2, 4096), #mobilenet #nn.Linear(7*7*1280*2,4096), #mnasnet nn.Linear(4096, 4096), nn.ReLU(inplace=True), nn.Dropout(), nn.Linear(4096, 4096), nn.ReLU(inplace=True), nn.Dropout(), nn.Linear(4096, 4096), nn.ReLU(inplace=True), nn.Dropout(), nn.Linear(4096, 4), ) self.weight_init() """ #UNCOMMENT DEPENDING ON THE PRETRAINED NETWORK YOU CHOSE self.classifier = nn.Sequential( #nn.Linear(256*6*6*2, 4096), #ALEXNET #nn.Linear(512*7*7*2, 4096), #VGG16 #nn.Linear(1280*7*7*2, 4096), #MOBILENET nn.Linear(7 * 7 * 1280 * 2, 4096), #MNASNET #nn.Linear(1024, 4096), #RESNET50 AND RESNET18 nn.ReLU(inplace=True), nn.Dropout(), nn.Linear(4096, 4096), nn.ReLU(inplace=True), nn.Dropout(), nn.Linear(4096, 4096), nn.ReLU(inplace=True), nn.Dropout(), nn.Linear(4096, 4), ) self.weight_init()
def get_model(name, device): if name == "normal_cnn": model = Net().to(device) return model elif name == "alexnet": model = models.alexnet().to(device) num_features = model.classifier[6].in_features model.classifier[6] = nn.Linear(num_features, 1).to(device) return model elif name == "vgg11": model = models.vgg11().to(device) num_features = model.classifier[6].in_features model.classifier[6] = nn.Linear(num_features, 1).to(device) return model elif name == "vgg13": model = models.vgg13().to(device) num_features = model.classifier[6].in_features model.classifier[6] = nn.Linear(num_features, 1).to(device) return model elif name == "vgg16": model = models.vgg16().to(device) num_features = model.classifier[6].in_features model.classifier[6] = nn.Linear(num_features, 1).to(device) return model elif name == "vgg19": model = models.vgg19().to(device) num_features = model.classifier[6].in_features model.classifier[6] = nn.Linear(num_features, 1).to(device) return model elif name == "vgg11_bn": model = models.vgg11_bn().to(device) num_features = model.classifier[6].in_features model.classifier[6] = nn.Linear(num_features, 1).to(device) return model elif name == "vgg13_bn": model = models.vgg13_bn().to(device) num_features = model.classifier[6].in_features model.classifier[6] = nn.Linear(num_features, 1).to(device) return model elif name == "vgg16_bn": model = models.vgg16_bn().to(device) num_features = model.classifier[6].in_features model.classifier[6] = nn.Linear(num_features, 1).to(device) return model elif name == "vgg19_bn": model = models.vgg19_bn().to(device) num_features = model.classifier[6].in_features model.classifier[6] = nn.Linear(num_features, 1).to(device) return model elif name == "densenet121": model = models.densenet121().to(device) num_features = model.classifier.in_features model.classifier = nn.Linear(num_features, 1).to(device) return model elif name == "densenet161": model = models.densenet161().to(device) num_features = model.classifier.in_features model.classifier = nn.Linear(num_features, 1).to(device) return model elif name == "densenet169": model = models.densenet169().to(device) num_features = model.classifier.in_features model.classifier = nn.Linear(num_features, 1).to(device) return model elif name == "densenet201": model = models.densenet201().to(device) num_features = model.classifier.in_features model.classifier = nn.Linear(num_features, 1).to(device) return model elif name == "resnet18": model = models.resnet18().to(device) num_features = model.fc.in_features model.fc = nn.Linear(num_features, 1).to(device) return model elif name == "resnet34": model = models.resnet34().to(device) num_features = model.fc.in_features model.fc = nn.Linear(num_features, 1).to(device) return model elif name == "resnet50": model = models.resnet50().to(device) num_features = model.fc.in_features model.fc = nn.Linear(num_features, 1).to(device) return model elif name == "resnet101": model = models.resnet101().to(device) num_features = model.fc.in_features model.fc = nn.Linear(num_features, 1).to(device) return model elif name == "resnet152": model = models.resnet152().to(device) num_features = model.fc.in_features model.fc = nn.Linear(num_features, 1).to(device) return model elif name == "googlenet": model = models.googlenet(aux_logits=False).to(device) num_features = model.fc.in_features model.fc = nn.Linear(num_features, 1).to(device) return model elif name == "inception_v3": model = models.inception_v3(aux_logits=False).to(device) num_features = model.fc.in_features model.fc = nn.Linear(num_features, 1).to(device) return model elif name == "shufflenet_v2_x0_5": model = models.shufflenet_v2_x0_5().to(device) num_features = model.fc.in_features model.fc = nn.Linear(num_features, 1).to(device) return model elif name == "shufflenet_v2_x1_0": model = models.shufflenet_v2_x1_0().to(device) num_features = model.fc.in_features model.fc = nn.Linear(num_features, 1).to(device) return model elif name == "shufflenet_v2_x1_5": model = models.shufflenet_v2_x1_5().to(device) num_features = model.fc.in_features model.fc = nn.Linear(num_features, 1).to(device) return model elif name == "shufflenet_v2_x2_0": model = models.shufflenet_v2_x2_0().to(device) num_features = model.fc.in_features model.fc = nn.Linear(num_features, 1).to(device) return model elif name == "mobilenet_v2": model = models.mobilenet_v2().to(device) num_features = model.classifier[1].in_features model.classifier[1] = nn.Linear(num_features, 1).to(device) return model elif name == "resnext50_32x4d": model = models.resnext50_32x4d().to(device) num_features = model.fc.in_features model.fc = nn.Linear(num_features, 1).to(device) return model elif name == "resnext101_32x8d": model = models.resnext101_32x8d().to(device) num_features = model.fc.in_features model.fc = nn.Linear(num_features, 1).to(device) return model elif name == "wide_resnet50_2": model = models.wide_resnet50_2().to(device) num_features = model.fc.in_features model.fc = nn.Linear(num_features, 1).to(device) return model elif name == "wide_resnet101_2": model = models.wide_resnet101_2().to(device) num_features = model.fc.in_features model.fc = nn.Linear(num_features, 1).to(device) return model elif name == "mnasnet0_5": model = models.mnasnet0_5().to(device) num_features = model.classifier[1].in_features model.classifier[1] = nn.Linear(num_features, 1).to(device) return model elif name == "mnasnet0_75": model = models.mnasnet0_75().to(device) num_features = model.classifier[1].in_features model.classifier[1] = nn.Linear(num_features, 1).to(device) return model elif name == "mnasnet1_0": model = models.mnasnet1_0().to(device) num_features = model.classifier[1].in_features model.classifier[1] = nn.Linear(num_features, 1).to(device) return model elif name == "mnasnet1_3": model = models.mnasnet1_3().to(device) num_features = model.classifier[1].in_features model.classifier[1] = nn.Linear(num_features, 1).to(device) return model
googlenet = models.googlenet(pretrained=pretrained) shufflenet_v2_x0_5 = models.shufflenet_v2_x0_5(pretrained=pretrained) shufflenet_v2_x1_0 = models.shufflenet_v2_x1_0(pretrained=pretrained) # shufflenet_v2_x1_5 = models.shufflenet_v2_x1_5(pretrained=pretrained) # shufflenet_v2_x2_0 = models.shufflenet_v2_x2_0(pretrained=pretrained) mobilenet_v2 = models.mobilenet_v2(pretrained=pretrained) resnext50_32x4d = models.resnext50_32x4d(pretrained=pretrained) resnext101_32x8d = models.resnext101_32x8d(pretrained=pretrained) wide_resnet50_2 = models.wide_resnet50_2(pretrained=pretrained) wide_resnet101_2 = models.wide_resnet101_2(pretrained=pretrained) mnasnet0_5 = models.mnasnet0_5(pretrained=pretrained) # mnasnet0_75 = models.mnasnet0_75(pretrained=pretrained) mnasnet1_0 = models.mnasnet1_0(pretrained=pretrained) # mnasnet1_3 = models.mnasnet1_3(pretrained=pretrained) data_transforms = { 'train': transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]), 'test': transforms.Compose([ transforms.Resize((224, 224)),
def export_pytorch_model(): net = models.mnasnet0_5(pretrained=True) net.eval() trace_model = torch.jit.trace(net, torch.Tensor(1, 3, 224, 224)) trace_model.save('./mnasnet0_5.pt')
print(classes_index) print("train data set:", len(data_image["train"])) print("val data set:", len(data_image["val"])) X_train, y_train = next(iter(data_loader_image["train"])) mean = [0.5, 0.5, 0.5] std = [0.5, 0.5, 0.5] img = torchvision.utils.make_grid(X_train) img = img.numpy().transpose((1, 2, 0)) img = img * std + mean print([classes[i] for i in y_train]) plt.imshow(img) model = models.mnasnet0_5(pretrained=True) print(model) for parma in model.parameters(): parma.requires_grad = False # model.avgpool = torch.nn.AdaptiveAvgPool2d((7,7)) model.classifier = torch.nn.Sequential(torch.nn.Linear(1280, 2)) for index, parma in enumerate(model.classifier.parameters()): if index == 6: parma.requires_grad = True if use_gpu: model = model.cuda() cost = torch.nn.CrossEntropyLoss()
def __init__(self, model_type=8, cnn_type='x0_5', cnn_layer_test=0): super(LightWeight_feat, self).__init__() self.model_type = model_type self.cnn_type = cnn_type self.use_layer = cnn_layer_test self.bn = True # BenchNorm # select cnn_model from SqueezeNet, MobileNet, ShuffleNet, MnasNet if self.model_type == LightCNN.SqueezeNet.value: # use SqueezeNet if cnn_type == '1_0': # V1_1_0 self.model = models.squeezenet1_0(pretrained=True) self.sel_feat_layer = {0, 4, 8, 12} # conv, conv2_2, conv3_2, cam else: # V1_x1_1 self.cnn_type = '1_1' self.model = models.squeezenet1_1(pretrained=True) self.sel_feat_layer = {0, 4, 7, 12} # conv, conv2_2, conv3_2, cam print('use SqueezeNet', self.cnn_type) elif self.model_type == LightCNN.MobileNet.value: # use MobileNet if cnn_type != 'Small': self.cnn_type = 'Large' self.model = MobileNet_feat(self.cnn_type, True, 1000) # Large, Small elif self.model_type == LightCNN.ShuffleNet.value: # use ShuffleNet if cnn_type == 'x0_5': # V2_x0.5 self.model = models.shufflenet_v2_x0_5(pretrained=True) else: # V2_x1.0 self.cnn_type = 'x1_0' self.model = models.shufflenet_v2_x1_0(pretrained=True) print('use ShuffleV2', self.cnn_type) elif self.model_type == LightCNN.MnasNet.value: # use MnasNet if cnn_type == '0_5': # MnasNet_0_5 self.model = models.mnasnet0_5(pretrained=True) else: # MnasNet_1_0 self.cnn_type = '1_0' self.model = models.mnasnet1_0(pretrained=True) self.sel_feat_layer = {6, 8, 10, 16} # conv1_3, conv2, conv4, cam print('use MnasNet', self.cnn_type) self.model.eval() # using Grad-CAM with softmax weight (FC) params = list(self.model.parameters()) self.weight_softmax = np.squeeze(params[-2].data.numpy()) if use_gpu: print('use cuda model') self.model = self.model.cuda() if self.model_type == LightCNN.SqueezeNet.value: self.features = nn.ModuleList(list(self.model.features)).eval() elif self.model_type == LightCNN.MnasNet.value: self.features = nn.ModuleList(list(self.model.layers)).eval() # test feature if self.use_layer == 0: # run combine cnn_features self.use_layer = -4 print('test linear combined cnn_features') elif self.use_layer > 4: # run combine features with grad-CAM print('test combined cnn_features with grad-CAM') else: # test each conv layers print('test single conv layer', self.use_layer)
def test_mnasnet0_5(self): process_model(models.mnasnet0_5(), self.image, _C_tests.forward_mnasnet0_5, "MNASNet0_5")
from torchvision.models import mnasnet0_5, mnasnet1_0 from torchsummary import summary if __name__ == '__main__': model = mnasnet0_5() summary(model, (3, 160, 160), batch_size=1, device="cpu")
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
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)
# elif (args.model=='resnext50_32x4d'): # model = models.resnext50_32x4d(pretrained=args.pretrain) # elif (args.model=='wide_resnet50_2'): # model = models.wide_resnet50_2(pretrained=args.pretrain) elif (args.model == 'mobilenet_v2'): # not doing well model = models.mobilenet_v2(pretrained=args.pretrain) model.classifier[1].out_features = num_classes elif (args.model == 'squeezenet1_0'): # doing well model = models.squeezenet1_0(pretrained=args.pretrain) model.classifier[1] = nn.Conv2d(512, num_classes, kernel_size=(1, 1), stride=(1, 1)) model.num_classes = num_classes elif (args.model == 'mnasnet0_5'): # not doing well model = models.mnasnet0_5(pretrained=args.pretrain) model.classifier[1].out_features = num_classes # elif (args.model=='shufflenet_v2_x0_5'): # model = models.shufflenet_v2_x0_5(pretrained=args.pretrain) else: print("Wrong model name!\n") exit() # print(model.fc) if args.use_cuda: model = model.cuda() # model = torch.nn.DataParallel(model).cuda() print('\ncuda is used, with %d gpu devices \n' % torch.cuda.device_count()) else:
def modeldict(mmd): if mmd == 'alexnet_pt': out_model = models.alexnet(pretrained=True) elif mmd == 'alexnet': out_model = models.alexnet(pretrained=False) elif mmd == 'vgg11_pt': out_model = models.vgg11(pretrained=True) elif mmd == 'vgg11': out_model = models.vgg11(pretrained=False) elif mmd == 'vgg11bn_pt': out_model = models.vgg11_bn(pretrained=True) elif mmd == 'vgg11bn': out_model = models.vgg11_bn(pretrained=False) elif mmd == 'vgg13_pt': out_model = models.vgg13(pretrained=True) elif mmd == 'vgg13': out_model = models.vgg13(pretrained=False) elif mmd == 'vgg13bn_pt': out_model = models.vgg13_bn(pretrained=True) elif mmd == 'vgg13bn': out_model = models.vgg13_bn(pretrained=False) elif mmd == 'vgg16_pt': out_model = models.vgg16(pretrained=True) elif mmd == 'vgg16': out_model = models.vgg16(pretrained=False) elif mmd == 'vgg16bn_pt': out_model = models.vgg16_bn(pretrained=True) elif mmd == 'vgg16bn': out_model = models.vgg16_bn(pretrained=False) elif mmd == 'vgg19_pt': out_model = models.vgg19(pretrained=True) elif mmd == 'vgg19': out_model = models.vgg19(pretrained=False) elif mmd == 'vgg19bn_pt': out_model = models.vgg19_bn(pretrained=True) elif mmd == 'vgg19bn': out_model = models.vgg19_bn(pretrained=False) elif mmd == 'resnet18': out_model = models.resnet18(pretrained=False) elif mmd == 'resnet18_pt': out_model = models.resnet18(pretrained=True) elif mmd == 'resnet34': out_model = models.resnet34(pretrained=False) elif mmd == 'resnet34_pt': out_model = models.resnet34(pretrained=True) elif mmd == 'resnet50': out_model = models.resnet50(pretrained=False) elif mmd == 'resnet50_pt': out_model = models.resnet50(pretrained=True) elif mmd == 'resnet101': out_model = models.resnet101(pretrained=False) elif mmd == 'resnet101_pt': out_model = models.resnet101(pretrained=True) elif mmd == 'resnet152': out_model = models.resnet152(pretrained=False) elif mmd == 'resnet152_pt': out_model = models.resnet152(pretrained=True) elif mmd == 'squeezenet10_pt': out_model = models.squeezenet1_0(pretrained=True) elif mmd == 'squeezenet10': out_model = models.squeezenet1_0(pretrained=False) elif mmd == 'squeezenet11_pt': out_model = models.squeezenet1_1(pretrained=True) elif mmd == 'squeezenet11': out_model = models.squeezenet1_1(pretrained=False) elif mmd == 'densenet121_pt': out_model = models.densenet121(pretrained=True) elif mmd == 'densenet121': out_model = models.densenet121(pretrained=False) elif mmd == 'densenet161_pt': out_model = models.densenet161(pretrained=True) elif mmd == 'densenet161': out_model = models.densenet161(pretrained=False) elif mmd == 'densenet169_pt': out_model = models.densenet169(pretrained=True) elif mmd == 'densenet169': out_model = models.densenet169(pretrained=False) elif mmd == 'densenet201_pt': out_model = models.densenet201(pretrained=True) elif mmd == 'densenet201': out_model = models.densenet201(pretrained=False) elif mmd == 'inception_pt': out_model = models.inception_v3(pretrained=True, aux_logits=False) elif mmd == 'inception': out_model = models.inception_v3(pretrained=False, aux_logits=False) elif mmd == 'inceptionv4_pt': out_model = pretrainedmodels.__dict__['inceptionv4']( num_classes=1000, pretrained='imagenet') elif mmd == 'inceptionv4': out_model = pretrainedmodels.__dict__['inceptionv4'](num_classes=1000, pretrained=None) elif mmd == 'inceptionresnetv2_pt': out_model = pretrainedmodels.__dict__['inceptionresnetv2']( num_classes=1000, pretrained='imagenet') elif mmd == 'inceptionresnetv2': out_model = pretrainedmodels.__dict__['inceptionresnetv2']( num_classes=1000, pretrained=None) elif mmd == 'googlenet_pt': out_model = models.googlenet(pretrained=True, aux_logits=False) elif mmd == 'googlenet': out_model = models.googlenet(pretrained=False, aux_logits=False) elif mmd == 'shufflenet05_pt': out_model = models.shufflenet_v2_x0_5(pretrained=True) elif mmd == 'shufflenet05': out_model = models.shufflenet_v2_x0_5(pretrained=False) elif mmd == 'shufflenet10_pt': out_model = models.shufflenet_v2_x1_0(pretrained=True) elif mmd == 'shufflenet10': out_model = models.shufflenet_v2_x1_0(pretrained=False) elif mmd == 'shufflenet20': out_model = models.shufflenet_v2_x2_0(pretrained=False) elif mmd == 'mobilenet_pt': out_model = models.mobilenet_v2(pretrained=True) elif mmd == 'mobilenet': out_model = models.mobilenet_v2(pretrained=False) elif mmd == 'resnext50_32x4d_pt': out_model = models.resnext50_32x4d(pretrained=True) elif mmd == 'resnext50_32x4d': out_model = models.resnext50_32x4d(pretrained=False) elif mmd == 'resnext101_32x8d_pt': out_model = models.resnext101_32x8d(pretrained=True) elif mmd == 'resnext101_32x8d': out_model = models.resnext101_32x8d(pretrained=False) elif mmd == 'wide_resnet50_2_pt': out_model = models.wide_resnet50_2(pretrained=True) elif mmd == 'wide_resnet50_2': out_model = models.wide_resnet50_2(pretrained=False) elif mmd == 'wide_resnet101_2_pt': out_model = models.wide_resnet101_2(pretrained=True) elif mmd == 'wide_resnet101_2': out_model = models.wide_resnet101_2(pretrained=False) elif mmd == 'mnasnet05_pt': out_model = models.mnasnet0_5(pretrained=True) elif mmd == 'mnasnet05': out_model = models.mnasnet0_5(pretrained=False) elif mmd == 'mnasnet075': out_model = models.mnasnet0_75(pretrained=False) elif mmd == 'mnasnet10_pt': out_model = models.mnasnet1_0(pretrained=True) elif mmd == 'mnasnet10': out_model = models.mnasnet1_0(pretrained=False) elif mmd == 'mnasnet13': out_model = models.mnasnet1_3(pretrained=False) elif mmd == 'xception_pt': out_model = pretrainedmodels.__dict__['xception']( num_classes=1000, pretrained='imagenet') elif mmd == 'xception': out_model = pretrainedmodels.__dict__['xception'](num_classes=1000, pretrained=None) elif mmd == 'dpn68_pt': out_model = pretrainedmodels.__dict__['dpn68'](num_classes=1000, pretrained='imagenet') elif mmd == 'dpn68': out_model = pretrainedmodels.__dict__['dpn68'](num_classes=1000, pretrained=None) elif mmd == 'dpn98_pt': out_model = pretrainedmodels.__dict__['dpn98'](num_classes=1000, pretrained='imagenet') elif mmd == 'dpn98': out_model = pretrainedmodels.__dict__['dpn98'](num_classes=1000, pretrained=None) elif mmd == 'dpn131_pt': out_model = pretrainedmodels.__dict__['dpn131'](num_classes=1000, pretrained='imagenet') elif mmd == 'dpn131': out_model = pretrainedmodels.__dict__['dpn131'](num_classes=1000, pretrained=None) elif mmd == 'dpn68b_pt': out_model = pretrainedmodels.__dict__['dpn68b']( num_classes=1000, pretrained='imagenet+5k') elif mmd == 'dpn68b': out_model = pretrainedmodels.__dict__['dpn68b'](num_classes=1000, pretrained=None) elif mmd == 'dpn92_pt': out_model = pretrainedmodels.__dict__['dpn92']( num_classes=1000, pretrained='imagenet+5k') elif mmd == 'dpn92': out_model = pretrainedmodels.__dict__['dpn92'](num_classes=1000, pretrained=None) elif mmd == 'dpn107_pt': out_model = pretrainedmodels.__dict__['dpn107']( num_classes=1000, pretrained='imagenet+5k') elif mmd == 'dpn107': out_model = pretrainedmodels.__dict__['dpn107'](num_classes=1000, pretrained=None) elif mmd == 'fbresnet152_pt': out_model = pretrainedmodels.__dict__['fbresnet152']( num_classes=1000, pretrained='imagenet') elif mmd == 'fbresnet152': out_model = pretrainedmodels.__dict__['fbresnet152'](num_classes=1000, pretrained=None) else: out_model = None print('Invalid model name. Terminated.') exit(0) return out_model
def buildModel(arch='vgg16', hidden_units=500, lr=0.001, n_output=102): """ Build a deep neural network model based on pretrained models provided by torchvision.models. It must be clear before choossing suitable model to be transfered into our own model. The VGG16 has been proved very accuracy. It archieved more than 95% accracy. (https://neurohive.io/en/popular-networks/vgg16/) From part I we can see VGG16 has 7 layers in its classifier pipeline. The hidden layer (position 3) has 4096 units. we can reduce the number. We can use replace its original layer with new layer by tunning some hyper-parameters. Args: arch (string) : the model's name (or architect) we choosen to use as pretrained base. hidden_units (int): The neural units (petron units) in hidden layer. lr (float) : The learning rate when perform gredient desent. n_output (int): The output layer must has the same number of units as the labels. Returns: model : The model with mdofiied classifiers. criterion: The loss function using NULLoss optimizer: The optimizer with Adam algotithm. """ # Load the specifc model from torchvision.models # We only provide vgg and mnasnet_05 as altenatives. # More models can be found at: https://pytorch.org/docs/stable/torchvision/models.html if arch == 'vgg11': model = models.vgg11(pretrained=True) elif arch == 'vgg13': model = models.vgg13(pretrained=True) elif arch == 'vgg19': model = models.vgg19(pretrained=True) elif arch == 'mnasanet': model = models.mnasnet0_5(pretrained=True) else: model = model = models.vgg16(pretrained=True) # Create our Lossfucntion(criterion) and optimizer. # Since this is a image classfication problem, we chosse the best loss function to be CrossEntropyLoss, # We use Adam as optimier set learning rate at 0.0001 criterion = nn.NLLLoss() optimizer = torch.optim.Adam(model.classifier.parameters(), lr) # Frezz model's parameters during the feature detection phrase. for param in model.parameters(): param.requires_grad = False # Input layer size n_input = model.classifier[0].in_features # Hidden layer size n_hidden = [hidden_units, 100] from collections import OrderedDict my_classifier = nn.Sequential( OrderedDict([('fc1', nn.Linear(n_input, n_hidden[0])), ('relu1', nn.ReLU()), ('dropout1', nn.Dropout(p=0.5)), ('fc2', nn.Linear(n_hidden[0], n_hidden[1])), ('relu2', nn.ReLU()), ('dropout2', nn.Dropout(p=0.5)), ('fc3', nn.Linear(n_hidden[1], n_output)), ('output', nn.LogSoftmax(dim=1))])) # Replace classifier model.classifier = my_classifier print('----------- model\'s classifier ----------') print('arch:', arch) print(model.classifier) return model, criterion, optimizer
def import_all(download): """ Commented out models do not have pre-trained variants available. This function will load and cache all of these models if they are not already cached. On CRC we can just run this initially as its own python script to download and cache the models. Afterwards, this function will be implemented into some other testing code that will call it in a similar fashion to what is shown below. """ print("Loading or checking if models are cached...\n") print( "This may take a while. Progress will be shown if models are being downloaded.\n " ) ############################################################################################ # Image Classification alexnet = models.alexnet(pretrained=download, progress=True) squeezenet1_0 = models.squeezenet1_0(pretrained=download, progress=True) squeezenet1_1 = models.squeezenet1_1(pretrained=download, progress=True) vgg16 = models.vgg16_bn(pretrained=download, progress=True) vgg19 = models.vgg19_bn(pretrained=download, progress=True) resnet18 = models.resnet18(pretrained=download, progress=True) resnet34 = models.resnet34(pretrained=download, progress=True) resnet50 = models.resnet50(pretrained=download, progress=True) resnet101 = models.resnet101(pretrained=download, progress=True) resnet152 = models.resnet152(pretrained=download, progress=True) densenet121 = models.densenet121(pretrained=download, progress=True, memory_efficient=False) densenet161 = models.densenet161(pretrained=download, progress=True, memory_efficient=False) densenet201 = models.densenet201(pretrained=download, progress=True, memory_efficient=False) densenet121_efficient = models.densenet121(pretrained=download, progress=True, memory_efficient=True) densenet161_efficient = models.densenet161(pretrained=download, progress=True, memory_efficient=True) densenet201_efficient = models.densenet201(pretrained=download, progress=True, memory_efficient=True) googlenet = models.googlenet(pretrained=download, progress=True) shufflenet_v2_1 = models.shufflenet_v2_x1_0(pretrained=download, progress=True) shufflenet_v2_0_5 = models.shufflenet_v2_x0_5(pretrained=download, progress=True) #shufflenet_v2_1_5 = models.shufflenet_v2_x1_5(pretrained=download, progress=True) #shufflenet_v2_2 = models.shufflenet_v2_x2_0(pretrained=download, progress=True) mobilenet_v2 = models.mobilenet_v2(pretrained=download, progress=True) resnext50_32x4d = models.resnext50_32x4d(pretrained=download, progress=True) resnext101_32x8d = models.resnext101_32x8d(pretrained=download, progress=True) wide_resnet50_2 = models.wide_resnet50_2(pretrained=download, progress=True) wide_resnet101_2 = models.wide_resnet101_2(pretrained=download, progress=True) mnasnet1_0 = models.mnasnet1_0(pretrained=download, progress=True) mnasnet0_5 = models.mnasnet0_5(pretrained=download, progress=True) #mnasnet0_75 = models.mnasnet0_75(pretrained=download, progress=True) #mnasnet1_3 = models.mnasnet1_3(pretrained=download, progress=True) efficientnet_b0 = EfficientNet.from_pretrained('efficientnet-b0') efficientnet_b1 = EfficientNet.from_pretrained('efficientnet-b1') efficientnet_b2 = EfficientNet.from_pretrained('efficientnet-b2') efficientnet_b3 = EfficientNet.from_pretrained('efficientnet-b3') efficientnet_b4 = EfficientNet.from_pretrained('efficientnet-b4') efficientnet_b5 = EfficientNet.from_pretrained('efficientnet-b5') efficientnet_b6 = EfficientNet.from_pretrained('efficientnet-b6') efficientnet_b7 = EfficientNet.from_pretrained('efficientnet-b7') # # # ########################################################################################### # # Video Classification # # resnet_3d = models.video.r3d_18(pretrained=download, progress=True) # # resnet_mixed_conv = models.video.mc3_18(pretrained=download, progress=True) # # resnet_2_1D = models.video.r2plus1d_18(pretrained=download, progress=True) # # ########################################################################################### # # Object Detection # fasterrcnn_resnet50 = models.detection.fasterrcnn_resnet50_fpn( pretrained=download, progress=True, num_classes=91, pretrained_backbone=True) maskcnn_resnet50 = models.detection.maskrcnn_resnet50_fpn( pretrained=download, progress=True, num_classes=91, pretrained_backbone=True) keypointrcnn_resnet50 = models.detection.keypointrcnn_resnet50_fpn( pretrained=download, progress=True, num_classes=2, num_keypoints=17, pretrained_backbone=True) # # ########################################################################################### # # Semantic Segmentation # fcn_resnet50 = models.segmentation.fcn_resnet50(pretrained=False, progress=True, num_classes=21, aux_loss=None) fcn_resnet101 = models.segmentation.fcn_resnet101(pretrained=download, progress=True, num_classes=21, aux_loss=None) deeplabv3_resnet50 = models.segmentation.deeplabv3_resnet50( pretrained=False, progress=True, num_classes=21, aux_loss=None) deeplabv3_resnet101 = models.segmentation.deeplabv3_resnet101( pretrained=False, progress=True, num_classes=21, aux_loss=None) ########################################################################################### # Generative Adversarial Networks ########################################################################################### models_dict = { "alexnet": alexnet, "fcn_resnet50": fcn_resnet50, "fcn_resnet101": fcn_resnet101, "deeplabv3_resnet50": deeplabv3_resnet50, "deeplabv3_resnet101": deeplabv3_resnet101, "squeezenet1_0": squeezenet1_0, "squeezenet1_1": squeezenet1_1, "vgg16": vgg16, "vgg19": vgg19, "resnet18": resnet18, "resnet34": resnet34, "resnet50": resnet50, "resnet101": resnet101, "resnet152": resnet152, "densenet121": densenet121, "densenet161": densenet161, "densenet201": densenet201, "densenet121_efficient": densenet121_efficient, "densenet161_efficient": densenet161_efficient, "densenet201_efficient": densenet201_efficient, "googlenet": googlenet, "shufflenet_v2_1": shufflenet_v2_1, "shufflenet_v2_0_5": shufflenet_v2_0_5, #"shufflenet_v2_1_5": shufflenet_v2_1_5, #"shufflenet_v2_2": shufflenet_v2_2, "mobilenet_v2": mobilenet_v2, "resnext50_32x4d": resnext50_32x4d, "resnext101_32x4d": resnext101_32x8d, "wide_resnet50_2": wide_resnet50_2, "wide_resnet101_2": wide_resnet101_2, "mnasnet1_0": mnasnet1_0, #"mnasnet1_3": mnasnet1_3, "mnasnet0_5": mnasnet0_5, #"mnasnet0_75": mnasnet0_75, "efficientnet_b0": efficientnet_b0, "efficientnet_b1": efficientnet_b1, "efficientnet_b2": efficientnet_b2, "efficientnet_b3": efficientnet_b3, "efficientnet_b4": efficientnet_b4, "efficientnet_b5": efficientnet_b5, "efficientnet_b6": efficientnet_b6, "efficientnet_b7": efficientnet_b7, } # "maskcnn_resnet50" : maskcnn_resnet50, # "keypointrcnn_resnet50" : keypointrcnn_resnet50, # "fasterrcnn_resnet50" : fasterrcnn_resnet50, # "resnet_3d" : resnet_3d, # "resnet_mixed_conv" : resnet_mixed_conv, # "resnet_2_1D" : resnet_2_1D, return models_dict
def mnasnet0_5(): return models.mnasnet0_5(pretrained=True)
def set_model(model_name, num_classes): if model_name == 'resnext50_32x4d': model = models.resnext50_32x4d(pretrained=True) model.fc = torch.nn.Sequential(torch.nn.Linear(in_features=2048, out_features=num_classes)) elif model_name == 'resnet18': model = models.resnet18(pretrained=True) model.fc = torch.nn.Linear(in_features=512, out_features=num_classes) elif model_name == 'resnet34': model = models.resnet34(pretrained=True) model.fc = torch.nn.Linear(in_features=512, out_features=num_classes) elif model_name == 'resnet50': model = models.resnet50(pretrained=True) model.fc = torch.nn.Linear(in_features=2048, out_features=num_classes) elif model_name == 'vgg16': model = models.vgg16(pretrained=True) model.classifier[6] = torch.nn.Linear(in_features=4096, out_features=num_classes) elif model_name == 'densenet121': model = models.densenet121(pretrained=True) model.classifier = torch.nn.Linear(in_features=1024, out_features=num_classes) elif model_name == 'densenet161': model = models.densenet161(pretrained=True) model.classifier = torch.nn.Linear(in_features=2208, out_features=num_classes) elif model_name == 'inception': model = models.inception_v3(pretrained=True) model.fc = torch.nn.Linear(in_features=2048, out_features=num_classes) elif model_name == 'googlenet': model = models.googlenet(pretrained=True) model.fc = torch.nn.Linear(in_features=1024, out_features=num_classes) elif model_name == 'shufflenet_v2_x0_5': model = models.shufflenet_v2_x0_5(pretrained=True) model.fc = torch.nn.Linear(in_features=1024, out_features=num_classes) elif model_name == 'shufflenet_v2_x1_0': model = models.shufflenet_v2_x1_0(pretrained=True) model.fc = torch.nn.Linear(in_features=1024, out_features=num_classes) elif model_name == 'mobilenet_v2': model = models.mobilenet_v2(pretrained=True) model.classifier[1] = torch.nn.Linear(in_features=1280, out_features=num_classes) elif model_name == 'mobilenet_v3_large': model = models.mobilenet_v3_large(pretrained=True) model.classifier[3] = torch.nn.Linear(in_features=1280, out_features=num_classes) elif model_name == 'mobilenet_v3_small': model = models.mobilenet_v3_small(pretrained=True) model.classifier[3] = torch.nn.Linear(in_features=1280, out_features=num_classes) elif model_name == 'wide_resnet50_2': model = models.wide_resnet50_2(pretrained=True) model.fc = torch.nn.Linear(in_features=2048, out_features=num_classes) elif model_name == 'mnasnet0_5': model = models.mnasnet0_5(pretrained=True) model.classifier[1] = torch.nn.Linear(in_features=1280, out_features=num_classes) elif model_name == 'mnasnet1_0': model = models.mnasnet1_0(pretrained=True) model.classifier[1] = torch.nn.Linear(in_features=1280, out_features=num_classes) elif model_name == 'alexnet': model = models.alexnet(pretrained=True) model.classifier[6] = torch.nn.Linear(in_features=4096, out_features=num_classes) elif model_name == 'vgg19_bn': model = models.vgg19_bn(pretrained=True) model.classifier[6] = torch.nn.Linear(in_features=4096, out_features=num_classes) elif model_name == 'efficientnet-b0': model = EfficientNet.from_pretrained(model_name, num_classes=num_classes) elif model_name == 'efficientnet-b1': model = EfficientNet.from_pretrained(model_name, num_classes=num_classes) elif model_name == 'efficientnet-b2': model = EfficientNet.from_pretrained(model_name, num_classes=num_classes) elif model_name == 'efficientnet-b3': model = EfficientNet.from_pretrained(model_name, num_classes=num_classes) elif model_name == 'efficientnet-b4': model = EfficientNet.from_pretrained(model_name, num_classes=num_classes) elif model_name == 'efficientnet-b5': model = EfficientNet.from_pretrained(model_name, num_classes=num_classes) elif model_name == 'efficientnet-b6': model = EfficientNet.from_pretrained(model_name, num_classes=num_classes) elif model_name == 'efficientnet-b7': model = EfficientNet.from_pretrained(model_name, num_classes=num_classes) else: raise NameError(f'!!!!! Model ERROR : {model_name} !!!!!') return model
def test_mnasnet0_5(self): process_model(models.mnasnet0_5(self.pretrained), self.image, _C_tests.forward_mnasnet0_5, 'MNASNet0_5')
def __init__(self, num_classes, trunk='resnet-101', criterion=None, criterion_aux=None, variant='D', skip='m1', skip_num=48, args=None): super(DeepV3PlusHANet, self).__init__() self.criterion = criterion self.criterion_aux = criterion_aux self.variant = variant self.args = args self.num_attention_layer = 0 self.trunk = trunk for i in range(5): if args.hanet[i] > 0: self.num_attention_layer += 1 print("#### HANet layers", self.num_attention_layer) if trunk == 'shufflenetv2': channel_1st = 3 channel_2nd = 24 channel_3rd = 116 channel_4th = 232 prev_final_channel = 464 final_channel = 1024 resnet = models.shufflenet_v2_x1_0(pretrained=True) self.layer0 = nn.Sequential(resnet.conv1, resnet.maxpool) self.layer1 = resnet.stage2 self.layer2 = resnet.stage3 self.layer3 = resnet.stage4 self.layer4 = resnet.conv5 if self.variant == 'D': for n, m in self.layer2.named_modules(): if isinstance(m, nn.Conv2d) and m.stride == (2, 2): m.dilation, m.padding, m.stride = (2, 2), (2, 2), (1, 1) for n, m in self.layer3.named_modules(): if isinstance(m, nn.Conv2d) and m.stride == (2, 2): m.dilation, m.padding, m.stride = (4, 4), (4, 4), (1, 1) elif self.variant == 'D16': for n, m in self.layer3.named_modules(): if isinstance(m, nn.Conv2d) and m.stride == (2, 2): m.dilation, m.padding, m.stride = (2, 2), (2, 2), (1, 1) else: # raise 'unknown deepv3 variant: {}'.format(self.variant) print("Not using Dilation ") elif trunk == 'mnasnet_05' or trunk == 'mnasnet_10': if trunk == 'mnasnet_05': resnet = models.mnasnet0_5(pretrained=True) channel_1st = 3 channel_2nd = 16 channel_3rd = 24 channel_4th = 48 prev_final_channel = 160 final_channel = 1280 print("# of layers", len(resnet.layers)) self.layer0 = nn.Sequential(resnet.layers[0], resnet.layers[1], resnet.layers[2], resnet.layers[3], resnet.layers[4], resnet.layers[5], resnet.layers[6], resnet.layers[7]) # 16 self.layer1 = nn.Sequential(resnet.layers[8], resnet.layers[9]) # 24, 40 self.layer2 = nn.Sequential(resnet.layers[10], resnet.layers[11]) # 48, 96 self.layer3 = nn.Sequential(resnet.layers[12], resnet.layers[13]) # 160, 320 self.layer4 = nn.Sequential(resnet.layers[14], resnet.layers[15], resnet.layers[16]) # 1280 else: resnet = models.mnasnet1_0(pretrained=True) channel_1st = 3 channel_2nd = 16 channel_3rd = 40 channel_4th = 96 prev_final_channel = 320 final_channel = 1280 print("# of layers", len(resnet.layers)) self.layer0 = nn.Sequential(resnet.layers[0], resnet.layers[1], resnet.layers[2], resnet.layers[3], resnet.layers[4], resnet.layers[5], resnet.layers[6], resnet.layers[7]) # 16 self.layer1 = nn.Sequential(resnet.layers[8], resnet.layers[9]) # 24, 40 self.layer2 = nn.Sequential(resnet.layers[10], resnet.layers[11]) # 48, 96 self.layer3 = nn.Sequential(resnet.layers[12], resnet.layers[13]) # 160, 320 self.layer4 = nn.Sequential(resnet.layers[14], resnet.layers[15], resnet.layers[16]) # 1280 if self.variant == 'D': for n, m in self.layer2.named_modules(): if isinstance(m, nn.Conv2d) and m.stride == (2, 2): m.dilation, m.padding, m.stride = (2, 2), (2, 2), (1, 1) for n, m in self.layer3.named_modules(): if isinstance(m, nn.Conv2d) and m.stride == (2, 2): m.dilation, m.padding, m.stride = (4, 4), (4, 4), (1, 1) elif self.variant == 'D16': for n, m in self.layer3.named_modules(): if isinstance(m, nn.Conv2d) and m.stride == (2, 2): m.dilation, m.padding, m.stride = (2, 2), (2, 2), (1, 1) else: # raise 'unknown deepv3 variant: {}'.format(self.variant) print("Not using Dilation ") elif trunk == 'mobilenetv2': channel_1st = 3 channel_2nd = 16 channel_3rd = 32 channel_4th = 64 # prev_final_channel = 160 prev_final_channel = 320 final_channel = 1280 resnet = models.mobilenet_v2(pretrained=True) self.layer0 = nn.Sequential(resnet.features[0], resnet.features[1]) self.layer1 = nn.Sequential(resnet.features[2], resnet.features[3], resnet.features[4], resnet.features[5], resnet.features[6]) self.layer2 = nn.Sequential(resnet.features[7], resnet.features[8], resnet.features[9], resnet.features[10]) # self.layer3 = nn.Sequential(resnet.features[11], resnet.features[12], resnet.features[13], resnet.features[14], resnet.features[15], resnet.features[16]) # self.layer4 = nn.Sequential(resnet.features[17], resnet.features[18]) self.layer3 = nn.Sequential( resnet.features[11], resnet.features[12], resnet.features[13], resnet.features[14], resnet.features[15], resnet.features[16], resnet.features[17]) self.layer4 = nn.Sequential(resnet.features[18]) if self.variant == 'D': for n, m in self.layer2.named_modules(): if isinstance(m, nn.Conv2d) and m.stride == (2, 2): m.dilation, m.padding, m.stride = (2, 2), (2, 2), (1, 1) for n, m in self.layer3.named_modules(): if isinstance(m, nn.Conv2d) and m.stride == (2, 2): m.dilation, m.padding, m.stride = (4, 4), (4, 4), (1, 1) elif self.variant == 'D16': for n, m in self.layer3.named_modules(): if isinstance(m, nn.Conv2d) and m.stride == (2, 2): m.dilation, m.padding, m.stride = (2, 2), (2, 2), (1, 1) else: # raise 'unknown deepv3 variant: {}'.format(self.variant) print("Not using Dilation ") else: channel_1st = 3 channel_2nd = 64 channel_3rd = 256 channel_4th = 512 prev_final_channel = 1024 final_channel = 2048 if trunk == 'resnet-50': resnet = Resnet.resnet50() resnet.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool) elif trunk == 'resnet-101': # three 3 X 3 resnet = Resnet.resnet101() resnet.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu1, resnet.conv2, resnet.bn2, resnet.relu2, resnet.conv3, resnet.bn3, resnet.relu3, resnet.maxpool) elif trunk == 'resnet-152': resnet = Resnet.resnet152() resnet.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool) elif trunk == 'resnext-50': resnet = models.resnext50_32x4d(pretrained=True) resnet.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool) elif trunk == 'resnext-101': resnet = models.resnext101_32x8d(pretrained=True) resnet.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool) elif trunk == 'wide_resnet-50': resnet = models.wide_resnet50_2(pretrained=True) resnet.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool) elif trunk == 'wide_resnet-101': resnet = models.wide_resnet101_2(pretrained=True) resnet.layer0 = nn.Sequential(resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool) else: raise ValueError("Not a valid network arch") self.layer0 = resnet.layer0 self.layer1, self.layer2, self.layer3, self.layer4 = \ resnet.layer1, resnet.layer2, resnet.layer3, resnet.layer4 if self.variant == 'D': for n, m in self.layer3.named_modules(): if 'conv2' in n: m.dilation, m.padding, m.stride = (2, 2), (2, 2), (1, 1) elif 'downsample.0' in n: m.stride = (1, 1) for n, m in self.layer4.named_modules(): if 'conv2' in n: m.dilation, m.padding, m.stride = (4, 4), (4, 4), (1, 1) elif 'downsample.0' in n: m.stride = (1, 1) elif self.variant == 'D4': for n, m in self.layer2.named_modules(): if 'conv2' in n: m.dilation, m.padding, m.stride = (2, 2), (2, 2), (1, 1) elif 'downsample.0' in n: m.stride = (1, 1) for n, m in self.layer3.named_modules(): if 'conv2' in n: m.dilation, m.padding, m.stride = (4, 4), (4, 4), (1, 1) elif 'downsample.0' in n: m.stride = (1, 1) for n, m in self.layer4.named_modules(): if 'conv2' in n: m.dilation, m.padding, m.stride = (8, 8), (8, 8), (1, 1) elif 'downsample.0' in n: m.stride = (1, 1) elif self.variant == 'D16': for n, m in self.layer4.named_modules(): if 'conv2' in n: m.dilation, m.padding, m.stride = (2, 2), (2, 2), (1, 1) elif 'downsample.0' in n: m.stride = (1, 1) else: # raise 'unknown deepv3 variant: {}'.format(self.variant) print("Not using Dilation ") if self.variant == 'D': os = 8 elif self.variant == 'D4': os = 4 elif self.variant == 'D16': os = 16 else: os = 32 self.aspp = _AtrousSpatialPyramidPoolingModule(final_channel, 256, output_stride=os) self.bot_fine = nn.Sequential( nn.Conv2d(channel_3rd, 48, kernel_size=1, bias=False), Norm2d(48), nn.ReLU(inplace=True)) self.bot_aspp = nn.Sequential( nn.Conv2d(1280, 256, kernel_size=1, bias=False), Norm2d(256), nn.ReLU(inplace=True)) self.final1 = nn.Sequential( nn.Conv2d(304, 256, kernel_size=3, padding=1, bias=False), Norm2d(256), nn.ReLU(inplace=True), nn.Conv2d(256, 256, kernel_size=3, padding=1, bias=False), Norm2d(256), nn.ReLU(inplace=True)) self.final2 = nn.Sequential( nn.Conv2d(256, num_classes, kernel_size=1, bias=True)) if self.args.aux_loss is True: self.dsn = nn.Sequential( nn.Conv2d(prev_final_channel, 512, kernel_size=3, stride=1, padding=1), Norm2d(512), nn.ReLU(inplace=True), nn.Dropout2d(0.1), nn.Conv2d(512, num_classes, kernel_size=1, stride=1, padding=0, bias=True)) initialize_weights(self.dsn) if self.args.hanet[0] == 1: self.hanet0 = HANet_Conv(prev_final_channel, final_channel, self.args.hanet_set[0], self.args.hanet_set[1], self.args.hanet_set[2], self.args.hanet_pos[0], self.args.hanet_pos[1], pos_rfactor=self.args.pos_rfactor, pooling=self.args.pooling, dropout_prob=self.args.dropout, pos_noise=self.args.pos_noise) initialize_weights(self.hanet0) if self.args.hanet[1] == 1: self.hanet1 = HANet_Conv(final_channel, 1280, self.args.hanet_set[0], self.args.hanet_set[1], self.args.hanet_set[2], self.args.hanet_pos[0], self.args.hanet_pos[1], pos_rfactor=self.args.pos_rfactor, pooling=self.args.pooling, dropout_prob=self.args.dropout, pos_noise=self.args.pos_noise) initialize_weights(self.hanet1) if self.args.hanet[2] == 1: self.hanet2 = HANet_Conv(1280, 256, self.args.hanet_set[0], self.args.hanet_set[1], self.args.hanet_set[2], self.args.hanet_pos[0], self.args.hanet_pos[1], pos_rfactor=self.args.pos_rfactor, pooling=self.args.pooling, dropout_prob=self.args.dropout, pos_noise=self.args.pos_noise) initialize_weights(self.hanet2) if self.args.hanet[3] == 1: self.hanet3 = HANet_Conv(304, 256, self.args.hanet_set[0], self.args.hanet_set[1], self.args.hanet_set[2], self.args.hanet_pos[0], self.args.hanet_pos[1], pos_rfactor=self.args.pos_rfactor, pooling=self.args.pooling, dropout_prob=self.args.dropout, pos_noise=self.args.pos_noise) initialize_weights(self.hanet3) if self.args.hanet[4] == 1: self.hanet4 = HANet_Conv(256, num_classes, self.args.hanet_set[0], self.args.hanet_set[1], self.args.hanet_set[2], self.args.hanet_pos[0], self.args.hanet_pos[1], pos_rfactor=self.args.pos_rfactor, pooling='max', dropout_prob=self.args.dropout, pos_noise=self.args.pos_noise) initialize_weights(self.hanet4) initialize_weights(self.aspp) initialize_weights(self.bot_aspp) initialize_weights(self.bot_fine) initialize_weights(self.final1) initialize_weights(self.final2)
elif TopModelName=='resnet101': pre_model = models.resnet101(pretrained=True, progress=True) elif TopModelName=='resnet152': pre_model = models.resnet152(pretrained=True, progress=True) elif TopModelName=="resnext50_32x4d": pre_model = models.resnext50_32x4d(pretrained=True, progress=True) elif TopModelName=='resnext101_32x8d': pre_model = models.resnext101_32x8d(pretrained=True, progress=True) elif TopModelName=="wide_resnet50_2": pre_model = models.wide_resnet50_2(pretrained=True, progress=True) elif TopModelName=='wide_resnet101_2': pre_model = models.wide_resnet101_2(pretrained=True, progress=True) ############################## elif TopModelName=="mnasnet0_5": pre_model = models.mnasnet0_5(pretrained=True, progress=True) elif TopModelName=="mnasnet0_75": pre_model = models.mnasnet0_75(pretrained=True, progress=True) elif TopModelName=="mnasnet1_0": pre_model = models.mnasnet1_0(pretrained=True, progress=True) elif TopModelName=="mnasnet1_3": pre_model = models.mnasnet1_3(pretrained=True, progress=True) elif TopModelName=="efficientnet-b0": from efficientnet_pytorch import EfficientNet pre_model = EfficientNet.from_pretrained('efficientnet-b0') ######################### Testing Models ################################# elif TopModelName=="resnext50_32x4d_test": model = models.resnext50_32x4d(pretrained=True, progress=True) model.conv1=nn.Conv2d(1, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False) model.fc.out_features=2
def create_model(model_type, num_classes, feature_extract, pretrained): """ Creates a model. :param model_type: Model type. :param num_classes: Number of classes. :param feature_extract: A boolean indicating if we are extracting features. :param pretrained: A boolean indicating if pretrained weights should be used. :return: Model. """ device = get_device() if 'resnet18' == model_type: model = models.resnet18(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.fc = nn.Linear(model.fc.in_features, num_classes) elif 'resnet34' == model_type: model = models.resnet34(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.fc = nn.Linear(model.fc.in_features, num_classes) elif 'resnet50' == model_type: model = models.resnet50(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.fc = nn.Linear(model.fc.in_features, num_classes) elif 'resnet101' == model_type: model = models.resnet101(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.fc = nn.Linear(model.fc.in_features, num_classes) elif 'resnet152' == model_type: model = models.resnet152(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.fc = nn.Linear(model.fc.in_features, num_classes) elif 'alexnet' == model_type: model = models.alexnet(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.classifier[6] = nn.Linear(4096, num_classes) elif 'vgg11' == model_type: model = models.vgg11(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.classifier[6] = nn.Linear(model.classifier[6].in_features, num_classes) elif 'vgg11_bn' == model_type: model = models.vgg11_bn(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.classifier[6] = nn.Linear(model.classifier[6].in_features, num_classes) elif 'vgg13' == model_type: model = models.vgg13(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.classifier[6] = nn.Linear(model.classifier[6].in_features, num_classes) elif 'vgg13_bn' == model_type: model = models.vgg13_bn(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.classifier[6] = nn.Linear(model.classifier[6].in_features, num_classes) elif 'vgg16' == model_type: model = models.vgg16(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.classifier[6] = nn.Linear(model.classifier[6].in_features, num_classes) elif 'vgg16_bn' == model_type: model = models.vgg16_bn(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.classifier[6] = nn.Linear(model.classifier[6].in_features, num_classes) elif 'vgg19' == model_type: model = models.vgg19(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.classifier[6] = nn.Linear(model.classifier[6].in_features, num_classes) elif 'vgg19_bn' == model_type: model = models.vgg19_bn(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.classifier[6] = nn.Linear(model.classifier[6].in_features, num_classes) elif 'squeezenet1_0' == model_type: model = models.squeezenet1_0(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.classifier[1] = nn.Conv2d(512, num_classes, kernel_size=(1, 1), stride=(1, 1)) model.num_classes = num_classes elif 'squeezenet1_1' == model_type: model = models.squeezenet1_1(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.classifier[1] = nn.Conv2d(512, num_classes, kernel_size=(1, 1), stride=(1, 1)) model.num_classes = num_classes elif 'densenet121' == model_type: model = models.densenet121(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.classifier = nn.Linear(model.classifier.in_features, num_classes) elif 'densenet161' == model_type: model = models.densenet161(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.classifier = nn.Linear(model.classifier.in_features, num_classes) elif 'densenet169' == model_type: model = models.densenet169(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.classifier = nn.Linear(model.classifier.in_features, num_classes) elif 'densenet201' == model_type: model = models.densenet201(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.classifier = nn.Linear(model.classifier.in_features, num_classes) elif 'googlenet' == model_type: model = models.googlenet(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.fc = nn.Linear(model.fc.in_features, num_classes) elif 'shufflenet_v2_x0_5' == model_type: model = models.shufflenet_v2_x0_5(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.fc = nn.Linear(model.fc.in_features, num_classes) elif 'shufflenet_v2_x1_0' == model_type: model = models.shufflenet_v2_x1_0(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.fc = nn.Linear(model.fc.in_features, num_classes) elif 'mobilenet_v2' == model_type: model = models.mobilenet_v2(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.classifier[1] = nn.Linear(model.classifier[1].in_features, num_classes) elif 'resnext50_32x4d' == model_type: model = models.resnext50_32x4d(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.classifier[1] = nn.Linear(model.classifier[1].in_features, num_classes) elif 'resnext101_32x8d' == model_type: model = models.resnext101_32x8d(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.fc = nn.Linear(model.fc.in_features, num_classes) elif 'wide_resnet50_2' == model_type: model = models.wide_resnet50_2(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.fc = nn.Linear(model.fc.in_features, num_classes) elif 'wide_resnet101_2' == model_type: model = models.wide_resnet101_2(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.fc = nn.Linear(model.fc.in_features, num_classes) elif 'mnasnet0_5' == model_type: model = models.mnasnet0_5(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.classifier[1] = nn.Linear(model.classifier[1].in_features, num_classes) elif 'mnasnet1_0' == model_type: model = models.mnasnet1_0(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.classifier[1] = nn.Linear(model.classifier[1].in_features, num_classes) else: model = models.inception_v3(pretrained=pretrained) set_parameter_requires_grad(model, feature_extract) model.AuxLogits.fc = nn.Linear(model.AuxLogits.fc.in_features, num_classes) model.fc = nn.Linear(model.fc.in_features, num_classes) return model.to(device)