def __init__(self, num_classes=1, num_filters=32, pretrained=False):
"""
:param num_classes:
:param num_filters:
:param pretrained:
False - no pre-trained network is used
True - encoder is pre-trained with VGG11
"""
super().__init__()
self.pool = nn.MaxPool2d(2, 2)
self.encoder = models.vgg11(pretrained=pretrained).features
self.relu = self.encoder[1]
self.conv1 = self.encoder[0]
self.conv2 = self.encoder[3]
self.conv3s = self.encoder[6]
self.conv3 = self.encoder[8]
self.conv4s = self.encoder[11]
self.conv4 = self.encoder[13]
self.conv5s = self.encoder[16]
self.conv5 = self.encoder[18]
self.center = DecoderBlock(num_filters * 8 * 2, num_filters * 8 * 2, num_filters * 8)
self.dec5 = DecoderBlock(num_filters * (16 + 8), num_filters * 8 * 2, num_filters * 8)
self.dec4 = DecoderBlock(num_filters * (16 + 8), num_filters * 8 * 2, num_filters * 4)
self.dec3 = DecoderBlock(num_filters * (8 + 4), num_filters * 4 * 2, num_filters * 2)
self.dec2 = DecoderBlock(num_filters * (4 + 2), num_filters * 2 * 2, num_filters)
self.dec1 = ConvRelu(num_filters * (2 + 1), num_filters)
self.final = nn.Conv2d(num_filters, num_classes, kernel_size=1)
def vgg11(num_classes=1000, pretrained='imagenet'):
"""VGG 11-layer model (configuration "A")
"""
model = models.vgg11(pretrained=False)
if pretrained is not None:
settings = pretrained_settings['vgg11'][pretrained]
model = load_pretrained(model, num_classes, settings)
return model
def __init__(self) -> None:
super().__init__()
_vgg = vgg11()
self._features = Sequential(
_vgg.features,
_vgg.avgpool,
)
self._projection = nn.Linear(512 * 7 * 7, 256)
self._prediction = nn.Linear(256, 256)
def vgg11(num_classes=1000, pretrained='imagenet'):
"""VGG 11-layer model (configuration "A")
"""
model = models.vgg11(pretrained=False)
if pretrained is not None:
settings = pretrained_settings['vgg11'][pretrained]
model = load_pretrained(model, num_classes, settings)
model = modify_vggs(model)
return model
def default_model():
"""
Build default model.
"""
network = models.vgg11(pretrained=True)
input_size = get_input_size(network)
default_classifier = Classifier(input_size, 102, [12544, 4096], [0.1, 0.1])
network.classifier = default_classifier
return network
def __init__(self,
arch: NetworkArchitectures = NetworkArchitectures.VGG16,
learning_rate: float = 0.0001,
dropout_rate: float = 0.2,
input_size: int = 25088,
hidden_units: Tuple = (12544, ),
output_size: int = 102,
model_state_dict: Dict = None,
epochs: int = 0,
class_to_idx: Dict = None,
criterion=nn.NLLLoss()):
"""
Constructor for a network.
:param arch: the network architecture
:param learning_rate: the learning rate used when training the network
:param dropout_rate: the dropout rate used when training the network
:param input_size: the input size of the classifier
:param hidden_units: the number of nodes in the classifier hidden layer
:param output_size: the output size of the classifier (should equal the number of categories)
:param model_state_dict: the state_dict of the model; used for saving & loading training progress
:param epochs: the number of epochs this network has been trained
:param class_to_idx: a dict of classes to indices (usually taken from a training image dataset)
:param criterion: function to calculate loss
"""
self.arch = arch
self.learning_rate = learning_rate
self.dropout_rate = dropout_rate
self.input_size = input_size
self.hidden_units = hidden_units
self.output_size = output_size
self.epochs = epochs
self.class_to_idx = class_to_idx
self.criterion = criterion
# Build the model using transfer learning, basing it off of the specified input architecture
if arch == NetworkArchitectures.VGG11:
self.model = models.vgg11(pretrained=True)
elif arch == NetworkArchitectures.VGG13:
self.model = models.vgg13(pretrained=True)
elif arch == NetworkArchitectures.VGG16:
self.model = models.vgg16(pretrained=True)
elif arch == NetworkArchitectures.VGG19:
self.model = models.vgg19(pretrained=True)
else:
raise ValueError('Invalid Network Architecture: {}'.format(arch))
# Freeze pre-trained parameters so we don't backpropagate through them
for param in self.model.parameters():
param.requires_grad = False
self.model.classifier = self.create_classifier()
self.optimizer = optim.Adam(self.model.classifier.parameters(),
lr=learning_rate)
if model_state_dict:
self.model_state_dict = model_state_dict
self.model.load_state_dict(model_state_dict)
def load_checkpoints(path):
lcheckpoint = torch.load(path)
if checkpoint['arch'] == 'vgg16':
model = models.vgg16(pretrained=True)
elif checkpoint['arch'] == 'vgg19':
model = models.vgg19(pretrained=True)
else checkpoint['arch'] == 'vgg11':
model = models.vgg11(pretrained=True)
def get_vgg11(class_num):
model = models.vgg11(pretrained=True)
set_parameter_requires_grad(model)
model.name = 'vgg11'
n_inputs = model.classifier[6].in_features
model.classifier[6] = nn.Linear(n_inputs, class_num)
return model, 224
def get_torchvision_model(arch):
if arch == 'vgg11':
return models.vgg11(pretrained=True)
elif arch == 'vgg16':
return models.vgg16(pretrained=True)
elif arch == 'alexnet':
return models.alexnet(pretrained=True)
else:
raise Exception('{} is not supported architecture'.format(arch))
def model_create(arch, hidden_units):
#if arch entered is vgg13
if arch == 'vgg13':
model = models.vgg13(pretrained=True)
for param in model.features.parameters():
param.requires_grad = False
#if hidden units are provided
if hidden_units:
classifier = nn.Sequential(
nn.Linear(25088, 512), nn.ReLU(), nn.Dropout(p=0.2),
nn.Linear(512, hidden_units), nn.ReLU(), nn.Dropout(p=0.2),
nn.Linear(hidden_units, len(cat_to_name)),
nn.LogSoftmax(dim=1))
#if hidden_units are not provided, default it to 256
else:
classifier = nn.Sequential(nn.Linear(25088, 512), nn.ReLU(),
nn.Dropout(p=0.2), nn.Linear(512, 256),
nn.ReLU(), nn.Dropout(p=0.2),
nn.Linear(256, len(cat_to_name)),
nn.LogSoftmax(dim=1))
#Else Loading the pre-trained model from PyTorch vgg11
else:
arch = 'vgg11'
model = models.vgg11(pretrained=True)
#Freeze training for all "features" layers
for param in model.features.parameters():
param.requires_grad = False
#if hidden units are provided
if hidden_units:
classifier = nn.Sequential(
nn.Linear(25088, 512), nn.ReLU(), nn.Dropout(p=0.2),
nn.Linear(512, hidden_units), nn.ReLU(), nn.Dropout(p=0.2),
nn.Linear(hidden_units, len(cat_to_name)),
nn.LogSoftmax(dim=1))
#if hidden_units are not provided, default it to 256
else:
classifier = nn.Sequential(nn.Linear(25088, 512), nn.ReLU(),
nn.Dropout(p=0.2), nn.Linear(512, 256),
nn.ReLU(), nn.Dropout(p=0.2),
nn.Linear(256, len(cat_to_name)),
nn.LogSoftmax(dim=1))
#Replacing the classifier in the pre-trained classifier with our classifier
model.classifier = classifier
return model, arch
def __init__(self, model_name, code_length, pretrained=True):
super(CNNNet, self).__init__()
if model_name == "alexnet":
original_model = models.alexnet(pretrained)
self.features = original_model.features
cl1 = nn.Linear(256 * 6 * 6, 4096)
cl2 = nn.Linear(4096, 4096)
if pretrained:
cl1.weight = original_model.classifier[1].weight
cl1.bias = original_model.classifier[1].bias
cl2.weight = original_model.classifier[4].weight
cl2.bias = original_model.classifier[4].bias
self.classifier = nn.Sequential(
nn.Dropout(),
cl1,
nn.ReLU(inplace=True),
nn.Dropout(),
cl2,
nn.ReLU(inplace=True),
nn.Linear(4096, code_length),
nn.Tanh()
)
self.model_name = 'alexnet'
if model_name == "vgg11":
original_model = models.vgg11(pretrained)
self.features = original_model.features
cl1 = nn.Linear(25088, 4096)
cl2 = nn.Linear(4096, 4096)
if pretrained:
cl1.weight = original_model.classifier[0].weight
cl1.bias = original_model.classifier[0].bias
cl2.weight = original_model.classifier[3].weight
cl2.bias = original_model.classifier[3].bias
self.classifier = nn.Sequential(
cl1,
nn.ReLU(inplace=True),
nn.Dropout(),
cl2,
nn.ReLU(inplace=True),
nn.Dropout(),
nn.Linear(4096, code_length),
nn.Tanh()
)
self.model_name = 'vgg11'
if model_name == 'resnet50':
original_model = models.resnet50(pretrained)
self.features = nn.Sequential(*list(original_model.children())[:-1])
self.classifier = nn.Sequential(
nn.Linear(2048, code_length),
nn.Tanh()
)
self.model_name = 'resnet50'
def __init__(self, name, nclasses=40, pretraining=True, cnn_name='vgg11'):
super(SVCNN, self).__init__(name)
self.classnames = [
'alexandrium', 'dinophysis', 'emiliania', 'gambier', 'larvezoe',
'ornithocercus', 'pluteuslarvae'
]
self.nclasses = nclasses
self.pretraining = pretraining
self.cnn_name = cnn_name
self.use_resnet = cnn_name.startswith('resnet')
self.mean = Variable(torch.FloatTensor([0.485, 0.456, 0.406]),
requires_grad=False).cuda()
self.std = Variable(torch.FloatTensor([0.229, 0.224, 0.225]),
requires_grad=False).cuda()
if self.use_resnet:
if self.cnn_name == 'resnet18':
self.net = models.resnet18(pretrained=self.pretraining)
self.net.fc = nn.Linear(512, self.nclasses)
elif self.cnn_name == 'resnet34':
self.net = models.resnet34(pretrained=self.pretraining)
self.net.fc = nn.Linear(512, self.nclasses)
elif self.cnn_name == 'resnet50':
self.net = models.resnet50(pretrained=self.pretraining)
self.net.fc = nn.Linear(2048, self.nclasses)
else:
if self.cnn_name == 'alexnet':
self.net_1 = models.alexnet(
pretrained=self.pretraining).features
self.net_2 = models.alexnet(
pretrained=self.pretraining).classifier
elif self.cnn_name == 'vgg11':
self.net_1 = models.vgg11(pretrained=self.pretraining).features
self.net_2 = models.vgg11(
pretrained=self.pretraining).classifier
elif self.cnn_name == 'vgg16':
self.net_1 = models.vgg16(pretrained=self.pretraining).features
self.net_2 = models.vgg16(
pretrained=self.pretraining).classifier
self.net_2._modules['6'] = nn.Linear(4096, self.nclasses)
def vgg11(num_classes=1000, pretrained='imagenet'):
"""VGG 11-layer model (configuration "A")
"""
model = models.vgg11(pretrained=False)
settings = pretrained_settings['vgg11']['imagenet']
if pretrained is not None:
model = load_pretrained(model, 1000, settings)
model = VGG(model, num_classes=num_classes, settings=settings)
return model
def __init__(self, nc=3):
super().__init__()
self.nc = nc
self.input = nn.Sequential(
Normalization(mean=torch.Tensor([0.485, 0.456, 0.406]),
std=torch.Tensor([0.229, 0.224, 0.225])),
nn.AdaptiveAvgPool2d(224))
self.vgg = models.vgg11(pretrained=True)
self.vgg.classifier = self.vgg.classifier[:-1]
def vgg_11(pretrain=True, input_channel=3, num_classes=1):
net = vgg11(pretrain)
if input_channel != 3:
net.features[0] = nn.Conv2d(in_channels=input_channel,
out_channels=64,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1))
net.classifier[6] = nn.Linear(4096, num_classes)
return net
def __init__(self, *args, **kwargs):
super(DilatedDecodingNet, self).__init__(*args, **kwargs)
self.features = models.vgg11(pretrained=True)
self.features.eval()
self.classifier = nn.Linear(512**2, TARGET_SIZE * 2)
self.gram = GramMatrix()
if USE_CUDA:
self.cuda()
def vgg11():
vgg = models.vgg11(pretrained=True)
vgg.eval()
for batch in 1, 2, 4, 8, 16, 32, 64:
filename = 'vgg11i' + str(batch) + '.onnx'
print(filename)
torch.onnx.export(vgg,
torch.randn(batch, 3, 224, 224),
filename,
keep_initializers_as_inputs=True)
def __init__(self, classes=10, pretrained=False):
super().__init__()
vgg = models.vgg11(pretrained=pretrained)
self.out_features = 4096
self.features = vgg.features
self.avgpool = vgg.avgpool
self.classifier = nn.Sequential(
*list(vgg.classifier._modules.values())[:-1],
nn.Linear(self.out_features, classes),
)
def CreateModel(model_name, bit, use_gpu):
if model_name == 'vgg11':
vgg11 = models.vgg11(pretrained=True)
cnn_model = CNN_model.cnn_model(vgg11, model_name, bit)
if model_name == 'alexnet':
alexnet = models.alexnet(pretrained=True)
cnn_model = CNN_model.cnn_model(alexnet, model_name, bit)
if use_gpu:
cnn_model = cnn_model.cuda()
return cnn_model
def __init__(self, requires_grad: bool = False):
super().__init__()
vgg16 = models.vgg11(pretrained=True)
self.vgg_pretrained_features = vgg16.features
self.avgpool = vgg16.avgpool
self.classifier = vgg16.classifier
if not requires_grad:
for parameter in self.parameters():
parameter.requires_grad = False
self.out_features = np.prod(self(torch.zeros(1, 3, 224, 224)).shape)
def CreateModel(model_name, bit, use_gpu):
if model_name == 'vgg11':
vgg11 = models.vgg11(pretrained=True)
hashnet = IDHashGAN_models.Hash_model(vgg11, model_name, bit)
if model_name == 'alexnet':
alexnet = models.alexnet(pretrained=True)
hashnet = IDHashGAN_models.Hash_model(alexnet, model_name, bit)
if use_gpu:
hashnet = hashnet.cuda()
return hashnet
def main():
# embedded = Generator()
# embedded.load_state_dict(torch.load("embedded.pt"))
res18_model = models.vgg11(pretrained=True)
embedded = ResNet50Bottom(res18_model)
for para in res18_model.parameters():
para.requires_grad = False
policy = MarioPolicyNetwork()
policy.load_state_dict(torch.load("policy.pt"))
render(policy, embedded, 'cpu')
def __init__(self):
super(ModifiedVGG16Model, self).__init__()
model = models.vgg11(pretrained=True)
self.features = model.features
for param in self.features.parameters():
param.requires_grad = False
self.classifier = model.classifier
def __init__(self, arch='vgg11', hidden_units=2048, device='cpu'):
"""Initialize Network
Args:
hidden_units: int (>0). classifier hidden units.
device: string ('cpu' or 'gpu').
"""
if arch not in ['vgg11', 'vgg13', 'vgg16', 'vgg19', 'vgg11_bn', 'vgg13_bn', 'vgg16_bn', 'vgg19_bn']:
raise ValueError("an architecture " + str(arch) + " is unsupported")
else:
if arch == 'vgg11':
self.__model = models.vgg11(pretrained=True)
elif arch == 'vgg13':
self.__model = models.vgg13(pretrained=True)
elif arch == 'vgg16':
self.__model = models.vgg16(pretrained=True)
elif arch == 'vgg19':
self.__model = models.vgg19(pretrained=True)
elif arch == 'vgg11_bn':
self.__model = models.vgg11_bn(pretrained=True)
elif arch == 'vgg13_bn':
self.__model = models.vgg13_bn(pretrained=True)
elif arch == 'vgg16_bn':
self.__model = models.vgg16_bn(pretrained=True)
elif arch == 'vgg19_bn':
self.__model = models.vgg19_bn(pretrained=True)
# Freeze parameters
for parameter in self.__model.parameters():
parameter.required_grad = False
# Define classifier
classifier = torch.nn.Sequential(OrderedDict([
('fc1', torch.nn.Linear(25088, hidden_units)),
('relu1', torch.nn.ReLU(inplace=True)),
('drop1', torch.nn.Dropout(0.5)),
('fc2', torch.nn.Linear(hidden_units, 102)),
('output', torch.nn.LogSoftmax(dim=1))
]))
# Replace classifier
self.__model.classifier = classifier
# Set device
self.__device = device
self.__model.to(self.__device)
# Set criterion
self.__criterion = torch.nn.NLLLoss()
# Set optimizer
self.__optimizer = torch.optim.Adam(self.__model.classifier.parameters())
# Set start epoch for continuous training
self.__current_epoch = 0
def get_classifier(classifier,
pretrained=True,
resnet34_8x_file=None,
num_classes=10):
if classifier == "none":
return NullTeacher(num_classes=num_classes)
else:
raise ValueError("Only Null Teacher should be used")
if classifier == 'vgg11_bn':
return vgg11_bn(pretrained=pretrained, num_classes=num_classes)
elif classifier == 'vgg13_bn':
return vgg13_bn(pretrained=pretrained, num_classes=num_classes)
elif classifier == 'vgg16_bn':
return vgg16_bn(pretrained=pretrained, num_classes=num_classes)
elif classifier == 'vgg19_bn':
return vgg19_bn(pretrained=pretrained, num_classes=num_classes)
if classifier == 'vgg11':
return models.vgg11(pretrained=pretrained, num_classes=num_classes)
elif classifier == 'vgg13':
return models.vgg13(pretrained=pretrained, num_classes=num_classes)
elif classifier == 'vgg16':
return models.vgg16(pretrained=pretrained, num_classes=num_classes)
elif classifier == 'vgg19':
return models.vgg19(pretrained=pretrained, num_classes=num_classes)
elif classifier == 'resnet18':
return resnet18(pretrained=pretrained, num_classes=num_classes)
elif classifier == 'resnet34':
return resnet34(pretrained=pretrained, num_classes=num_classes)
elif classifier == 'resnet50':
return resnet50(pretrained=pretrained, num_classes=num_classes)
elif classifier == 'densenet121':
return densenet121(pretrained=pretrained, num_classes=num_classes)
elif classifier == 'densenet161':
return densenet161(pretrained=pretrained, num_classes=num_classes)
elif classifier == 'densenet169':
return densenet169(pretrained=pretrained, num_classes=num_classes)
elif classifier == 'mobilenet_v2':
return mobilenet_v2(pretrained=pretrained, num_classes=num_classes)
elif classifier == 'googlenet':
return googlenet(pretrained=pretrained, num_classes=num_classes)
elif classifier == 'inception_v3':
return inception_v3(pretrained=pretrained, num_classes=num_classes)
elif classifier == "resnet34_8x":
net = network.resnet_8x.ResNet34_8x(num_classes=num_classes)
if pretrained:
if resnet34_8x_file is not None:
net.load_state_dict(torch.load(resnet34_8x_file))
else:
raise ValueError(
"Cannot load pretrained resnet34_8x from here")
return net
else:
raise NameError(f'Please enter a valid classifier {classifier}')
def __init__(self, num_filters=32, pretrained=False):
"""
:param num_classes:
:param num_filters:
:param pretrained:
False - no pre-trained network used
vgg - encoder pre-trained with VGG11
carvana - all weights pre trained on
Kaggle: Carvana dataset https://www.kaggle.com/c/carvana-image-masking-challenge
"""
super().__init__()
self.pool = nn.MaxPool2d(2, 2)
if pretrained == 'vgg':
self.encoder = models.vgg11(pretrained=True).features
else:
self.encoder = models.vgg11(pretrained=False).features
self.relu = self.encoder[1]
self.conv1 = self.encoder[0]
self.conv2 = self.encoder[3]
self.conv3s = self.encoder[6]
self.conv3 = self.encoder[8]
self.conv4s = self.encoder[11]
self.conv4 = self.encoder[13]
self.conv5s = self.encoder[16]
self.conv5 = self.encoder[18]
self.center = DecoderBlock(num_filters * 8 * 2, num_filters * 8 * 2,
num_filters * 8)
self.dec5 = DecoderBlock(num_filters * (16 + 8), num_filters * 8 * 2,
num_filters * 8)
self.dec4 = DecoderBlock(num_filters * (16 + 8), num_filters * 8 * 2,
num_filters * 4)
self.dec3 = DecoderBlock(num_filters * (8 + 4), num_filters * 4 * 2,
num_filters * 2)
self.dec2 = DecoderBlock(num_filters * (4 + 2), num_filters * 2 * 2,
num_filters)
self.dec1 = ConvRelu(num_filters * (2 + 1), num_filters)
self.final = nn.Conv2d(num_filters, 1, kernel_size=1)
def build_model(arch, inputs, hidden_units, output, rate):
"""
This function builds the model to be used in training or predition using
the parameters passed
Params:
arch - Model architecture/type to be used
hidden_units - Number of hidden units to be used in classifier
Returns:
model - Model with replace classifier and freezed gradients
"""
fc1_input = inputs if inputs else 25088
fc2_output = output if output else 102
dp_rate = rate if rate else 0.2
#Check if arch is valid and load the correct model
model_options = ["vgg11", "vgg13", "vgg19"]
if arch in model_options:
print("Building model ---> arch: {}".format(arch))
if arch == "vgg19":
model = models.vgg19(pretrained=True)
elif arch == "vgg13":
model = models.vgg13(pretrained=True)
else:
model = models.vgg11(pretrained=True)
else:
print("Invalid model: {} --> Using arch: vgg11".format(arch))
model = models.vgg11(pretrained=True)
#Freezes gradients
for param in model.parameters():
param.requires_grad = False
#Build classifier and replace it in model
classifier = nn.Sequential(
OrderedDict([("fc1", nn.Linear(fc1_input, hidden_units)),
("relu", nn.ReLU()), ("drop", nn.Dropout(p=dp_rate)),
("fc2", nn.Linear(hidden_units, fc2_output)),
("output", nn.LogSoftmax(dim=1))]))
model.classifier = classifier
return model
def __init__(self):
super().__init__()
self.features = models.vgg11(pretrained=True).features
self.regressor = torch.nn.Sequential(
torch.nn.Linear(512 * 7 * 7, units1),
torch.nn.Sigmoid(),
torch.nn.Linear(units1, units2),
torch.nn.Sigmoid(),
torch.nn.Linear(units2, 1),
torch.nn.Sigmoid()
)
def __init__(self, num_classes=1, num_filters=32, pretrained=False):
"""
:param num_classes:
:param num_filters:
:param pretrained:
False - no pre-trained network used
True - encoder pre-trained with VGG11
"""
super().__init__()
self.pool = nn.MaxPool2d(2, 2)
self.num_classes = num_classes
self.encoder = models.vgg11(pretrained=pretrained).features
self.relu = nn.ReLU(inplace=True)
self.conv1 = nn.Sequential(self.encoder[0], self.relu)
self.conv2 = nn.Sequential(self.encoder[3], self.relu)
self.conv3 = nn.Sequential(
self.encoder[6],
self.relu,
self.encoder[8],
self.relu,
)
self.conv4 = nn.Sequential(
self.encoder[11],
self.relu,
self.encoder[13],
self.relu,
)
self.conv5 = nn.Sequential(
self.encoder[16],
self.relu,
self.encoder[18],
self.relu,
)
self.center = DecoderBlockUpsample(256 + num_filters * 8,
num_filters * 8 * 2,
num_filters * 8)
self.dec5 = DecoderBlockUpsample(512 + num_filters * 8,
num_filters * 8 * 2, num_filters * 8)
self.dec4 = DecoderBlockUpsample(512 + num_filters * 8,
num_filters * 8 * 2, num_filters * 4)
self.dec3 = DecoderBlockUpsample(256 + num_filters * 4,
num_filters * 4 * 2, num_filters * 2)
self.dec2 = DecoderBlockUpsample(128 + num_filters * 2,
num_filters * 2 * 2, num_filters)
self.dec1 = ConvRelu(64 + num_filters, num_filters)
self.final = nn.Conv2d(num_filters, num_classes, kernel_size=1)
def adjusted_VGG(self):
model = models.vgg11(pretrained=True)
model.classifier[0] = torch.nn.Linear(in_features=25088, out_features=1024, bias=True)
model.classifier[2] = torch.nn.Dropout(0.2)
model.classifier[3] = torch.nn.Linear(in_features=1024, out_features=256, bias=True)
model.classifier[5] = torch.nn.Dropout(0.2)
model.classifier[6] = torch.nn.Linear(in_features=256, out_features=2, bias=True)
for param in model.features.parameters():
param.requires_grad = False
#print(model)
return model
def vgg11_FlowerModel(nhu):
model = models.vgg11(pretrained=True)
model.name = "vgg"
for param in model.parameters():
param.requires_grad = False
classifier = nn.Sequential(
OrderedDict([('fc1', nn.Linear(25088, nhu)), ('relu', nn.ReLU()),
('fc2', nn.Linear(nhu, 102)),
('output', nn.LogSoftmax(dim=1))]))
model.classifier = classifier
return model
def __init__(self, num_filters=32, num_bands=8, pretrained=False):
"""
:param num_classes:
:param num_filters:
:param pretrained:
False - no pre-trained network is used
True - encoder is pre-trained with VGG11
"""
super().__init__()
self.pool = nn.MaxPool2d(2, 2)
self.encoder = models.vgg11(pretrained=pretrained).features
self.relu = self.encoder[1]
# change the encoder[0] to support many bands
self.encoder[0] = nn.Sequential(
nn.Conv2d(num_bands,
64,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)))
# changed this one
print('num_bands is ', num_bands)
self.conv1 = nn.Sequential(
nn.Conv2d(num_bands,
64,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), # support for multiple bands
self.relu)
self.relu = self.encoder[1]
self.conv1 = self.encoder[0]
self.conv2 = self.encoder[3]
self.conv3s = self.encoder[6]
self.conv3 = self.encoder[8]
self.conv4s = self.encoder[11]
self.conv4 = self.encoder[13]
self.conv5s = self.encoder[16]
self.conv5 = self.encoder[18]
self.center = DecoderBlock(num_filters * 8 * 2, num_filters * 8 * 2,
num_filters * 8)
self.dec5 = DecoderBlock(num_filters * (16 + 8), num_filters * 8 * 2,
num_filters * 8)
self.dec4 = DecoderBlock(num_filters * (16 + 8), num_filters * 8 * 2,
num_filters * 4)
self.dec3 = DecoderBlock(num_filters * (8 + 4), num_filters * 4 * 2,
num_filters * 2)
self.dec2 = DecoderBlock(num_filters * (4 + 2), num_filters * 2 * 2,
num_filters)
self.dec1 = ConvRelu(num_filters * (2 + 1), num_filters)
self.final = nn.Conv2d(num_filters, 1, kernel_size=1)
