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)
