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