def create_model(model="vgg19", pool="avg", padding="valid"):
if model == "vgg19":
default_model = vgg19.VGG19(weights="imagenet", include_top=False)
elif model == "vgg16":
default_model = vgg16.VGG16(weights="imagenet", include_top=False)
new_layers = []
for i, layer in enumerate(default_model.layers):
if i == 0:
new_layers.append(keras.layers.Input((None, None, 3)))
else:
if isinstance(layer, keras.layers.Conv2D):
config = layer.get_config()
config["padding"] = padding
new_layers.append(keras.layers.Conv2D.from_config(config))
elif isinstance(layer, keras.layers.MaxPooling2D):
config = layer.get_config()
config["padding"] = padding
if pool == "avg":
new_layers.append(
keras.layers.AveragePooling2D.from_config(config))
else:
new_layers.append(
keras.layers.MaxPooling2D.from_config(config))
input = new_layers[0]
output = input
for i in range(1, len(new_layers)):
output = new_layers[i](output)
model = keras.models.Model(input, output)
for new, old in zip(model.layers, default_model.layers):
new.set_weights(old.get_weights())
return model
def vgg_layers(layer_names):
vgg = vgg19.VGG19(include_top=False, weights='imagenet')
# frozen the weight
vgg.trainable = False
outputs = [vgg.get_layer(name).output for name in layer_names]
return models.Model([vgg.input], outputs)
def create_vgg_model():
model=vgg19.VGG19(include_top=False,pooling='avg',weights='imagenet')
model.trainable=False
content_layer=CONTENT_LAYERS
style_layer=STYLE_LAYERS
output_layers=[model.get_layer(layer).output for layer in (content_layer + style_layer)]
return tf.keras.models.Model(model.input,output_layers)
def styleTransfer(cData, sData, tData):
print(" Building transfer model.")
contentTensor = K.variable(cData)
styleTensor = K.variable(sData)
genTensor = K.placeholder((1, CONTENT_IMG_H, CONTENT_IMG_W, 3))
inputTensor = K.concatenate([contentTensor, styleTensor, genTensor],
axis=0)
model = vgg19.VGG19(include_top=False,
weights="imagenet",
input_tensor=inputTensor) #TODO: implement.
outputDict = dict([(layer.name, layer.output) for layer in model.layers])
print(" VGG19 model loaded.")
loss = 0.0
styleLayerNames = [
"block1_conv1", "block2_conv1", "block3_conv1", "block4_conv1",
"block5_conv1"
]
contentLayerName = "block5_conv2"
print(" Calculating content loss.")
contentLayer = outputDict[contentLayerName]
contentOutput = contentLayer[0, :, :, :]
genOutput = contentLayer[2, :, :, :]
loss += CONTENT_WEIGHT * contentLoss(contentOutput,
genOutput) #TODO: implement.
print(" Calculating style loss.")
for layerName in styleLayerNames:
styleLayer = outputDict[layerName]
styleOutput = styleLayer[1, :, :, :]
genOutput = styleLayer[2, :, :, :]
loss += (STYLE_WEIGHT / len(styleLayerNames)) * styleLoss(
styleOutput, genOutput) #TODO: implement.
loss += TOTAL_WEIGHT * totalLoss(genTensor) #TODO: implement.
# TODO: Setup gradients or use K.gradients().
gradient = K.gradients(loss, genTensor)
#create K.function to output loss and gradients
print(type(gradient))
outputs = [loss]
outputs += gradient
global f_outputs
global x
f_outputs = K.function([genTensor], outputs)
x = cData
print(" Beginning transfer.")
for i in range(TRANSFER_ROUNDS):
print(" Step %d." % i)
#TODO: perform gradient descent using fmin_l_bfgs_b.
start_time = time.time()
x, tLoss, ph = fmin_l_bfgs_b(evaluator.loss,
x.flatten(),
fprime=evaluator.grads,
maxfun=20)
print(" Loss: %f." % tLoss)
img = deprocessImage(x.copy())
filename = 'hello' + str(i)
saveFile = filename + '.jpg' #TODO: Implement.
imsave(saveFile, img) #Uncomment when everything is working right.
end_time = time.time()
print(" Image saved to \"%s\"." % saveFile)
print('Iteration %d completed in %ds' % (i, end_time - start_time))
def styleTransfer(cData, sData, tData):
print(" Building transfer model.")
contentTensor = K.variable(cData)
styleTensor = K.variable(sData)
genTensor = K.placeholder((1, CONTENT_IMG_H, CONTENT_IMG_W, 3))
inputTensor = K.concatenate([contentTensor, styleTensor, genTensor], axis=0)
model = vgg19.VGG19(include_top=False, weights="imagenet", input_tensor=inputTensor)
outputDict = dict([(layer.name, layer.output) for layer in model.layers])
print(" VGG19 model loaded.")
styleLayerNames = ["block1_conv1", "block2_conv1", "block3_conv1", "block4_conv1", "block5_conv1"]
contentLayerName = "block5_conv2"
loss = compute_loss(genTensor, outputDict, styleLayerNames, contentLayerName)
# Setup gradients or use K.gradients().
grads = K.gradients(loss, genTensor)
kFunction = K.function([genTensor], [loss] + grads)
evaluator = Evaluator(kFunction)
print(" Beginning transfer.")
x = tData
for i in range(TRANSFER_ROUNDS):
print(" Step %d." % i)
# perform gradient descent using fmin_l_bfgs_b.
x, tLoss, info = fmin_l_bfgs_b(evaluator.loss, x.flatten(), fprime=evaluator.grads, maxiter=20)
print(" Loss: %f." % tLoss)
img = deprocessImage(x.copy())
saveFile = CONTENT_IMG_PATH[:-4] + STYLE_IMG_PATH[:-4] + str(i) + ".jpg"
imageio.imwrite(saveFile, img)
print(" Image saved to \"%s\"." % saveFile)
print(" Transfer complete.")
def make_model(self):
# Build a VGG19 model loaded with pre-trained ImageNet weights
self.model = vgg19.VGG19(weights="imagenet", include_top=False)
# Get the symbolic outputs of each "key" layer (we gave them unique names).
self.outputs_dict = dict([(layer.name, layer.output)
for layer in self.model.layers])
# Set up a model that returns the activation values for every layer in VGG19 (as a dict).
self.feature_extractor = keras.Model(inputs=self.model.inputs,
outputs=self.outputs_dict)
# List of layers to use for the style loss.
self.style_layer_names = [
"block1_conv1",
"block2_conv1",
"block3_conv1",
"block4_conv1",
"block5_conv1",
]
# The layer to use for the content loss.
self.content_layer_name = "block5_conv2"
self.optimizer = keras.optimizers.SGD(
keras.optimizers.schedules.ExponentialDecay(
initial_learning_rate=100.0, decay_steps=100, decay_rate=0.96))
def __init__(self, settings: Settings, view_id, *args, **kwargs):
super().__init__(*args, **kwargs)
self.settings = settings
self.view_id = view_id
# region Use VGG16
if self.settings.svcnn_model == 'vgg16':
vgg16_model = vgg16.VGG16(include_top=False,
input_shape=settings.input_shape,
pooling=None,
weights=None)
x = vgg16_model.layers[-1].output
x = Flatten(name='flatten')(x)
x = Dense(4096, activation='relu', name='fc1')(x)
x = Dense(4096, activation='relu', name='fc2')(x)
x = Dense(settings.num_classes,
activation='softmax',
name='predictions')(x)
self.model_input = vgg16_model.input
self.model_output = x
self.model = Model(inputs=self.model_input,
outputs=self.model_output)
# endregion
# region Use VGG19
elif self.settings.svcnn_model == 'vgg19':
vgg19_model = vgg19.VGG19(include_top=False,
input_shape=settings.input_shape,
pooling=None,
weights=None)
x = vgg19_model.layers[-1].output
x = Flatten(name='flatten')(x)
x = Dense(4096, activation='relu', name='fc1')(x)
x = Dense(4096, activation='relu', name='fc2')(x)
x = Dense(settings.num_classes,
activation='softmax',
name='predictions')(x)
self.model_input = vgg19_model.input
self.model_output = x
self.model = Model(inputs=self.model_input,
outputs=self.model_output)
# endregion
# region Use ResNet50
elif self.settings.svcnn_model == 'resnet50':
resnet50_model = resnet50.ResNet50(
include_top=False,
input_shape=settings.input_shape,
pooling=None,
weights=None)
x = resnet50_model.layers[-1].output
x = GlobalAveragePooling2D(name='avg_pool')(x)
x = Dense(settings.num_classes, activation='softmax',
name='probs')(x)
self.model_input = resnet50_model.input
self.model_output = x
self.model = Model(inputs=self.model_input,
outputs=self.model_output)
def create_model(content_layers, style_layers):
vgg = vgg19.VGG19(include_top=False, weights="imagenet")
vgg.trainable = False
style_outputs = [vgg.get_layer(name).output for name in style_layers]
content_outputs = [vgg.get_layer(name).output for name in content_layers]
model_outputs = style_outputs + content_outputs
return Model(vgg.input, model_outputs)
def make_model():
base_model = vgg19.VGG19(include_top=False, weights='imagenet')
base_model.trainable = False
content_layers = CONTENT_LAYERS
style_layers = STYLE_LAYERS
output_layers = [
base_model.get_layer(layer).output
for layer in (content_layers + style_layers)
]
return tf.keras.models.Model(base_model.input, output_layers)
def make_model(self, include_full=False, input_shape=None):
if include_full:
base_model = vgg19.VGG19(include_top=True, weights="imagenet")
return base_model
elif input_shape is not None:
base_model = vgg19.VGG19(include_top=False,
input_shape=input_shape,
weights="imagenet")
else:
base_model = vgg19.VGG19(include_top=False, weights="imagenet")
base_model.trainable = False
content_layers = self.CONTENT_LAYERS
style_layers = self.OUTPUT_LAYERS
output_layers = [
base_model.get_layer(layer).output
for layer in (content_layers + style_layers)
]
return tf.keras.models.Model(base_model.input, output_layers)
def load_model(self, input_tensor):
"""load_model
@Load Model VGG19
:param input_tensor: dedicate input shape to use in VGG19
-type input_tensor : tensoflow Tensor
:return: model (VGG19)
"""
model = vgg19.VGG19(input_tensor=input_tensor,weights='imagenet', include_top=False)
return model
def vgg_layers(layer_names, shape):
vgg = vgg19.VGG19(include_top=False,
weights='imagenet',
input_shape=shape,
pooling='max')
vgg.trainable = False
outputs = [vgg.get_layer(name).output for name in layer_names]
model = tf.keras.Model(inputs=vgg.input, outputs=outputs)
return model
def createVGGNetwork():
model = vgg19.VGG19(weights='imagenet')
for layer in model.layers:
layer._name = 'vgg_'+layer._name
x = Flatten()(model.get_layer('vgg_block5_pool').output)
x = Dropout(0.3)(x)
x = Dense(256, name='vgg_weights', activation=LeakyReLU(alpha=0.3))(x)
x = Dense(4, activation='softmax')(x)
model = Model(model.input, x)
return model
def run(job_dir, style_targets, style_targets_root, dataset, max_steps,
save_summary_steps, batch_size, depthwise_separable_conv,
learning_rate, style_layers, content_layers, style_weight,
content_weight):
with tf.summary.create_file_writer(job_dir).as_default():
transform_net = build_transformation_network(
n_styles=len(style_targets),
depthwise_separable_conv=depthwise_separable_conv)
transform_net.summary()
vgg = vgg19.VGG19(include_top=False, weights="imagenet")
vgg.trainable = False
for layer in vgg.layers:
layer.trainable = False
content_outputs = [vgg.get_layer(l).output for l in content_layers]
style_outputs = [vgg.get_layer(l).output for l in style_layers]
loss_net = Model(vgg.input, style_outputs + content_outputs)
style_images_processed = [
load_and_preprocess_image("%s/%s" %
(style_targets_root, style_target))
for style_target in style_targets
]
style_images = tf.squeeze(tf.stack(style_images_processed))
style_features = loss_net(style_images)[:len(style_layers)]
style_features = [gram_matrix(a) for a in style_features]
style_features = [
tf.tile(style_feature, [batch_size, 1, 1])
for style_feature in style_features
]
optimizer = tf.keras.optimizers.Adam(learning_rate=learning_rate,
beta_1=0.9,
beta_2=0.999)
train(dataset=dataset,
max_steps=max_steps,
save_summary_steps=save_summary_steps,
optimizer=optimizer,
n_styles=len(style_targets),
style_layers=style_layers,
style_features=style_features,
style_weight=style_weight,
content_weight=content_weight,
transform_net=transform_net,
loss_net=loss_net)
return transform_net, style_images_processed
def get_model(layer_names):
"""Define model using pretrained vgg19"""
vgg = vgg19.VGG19(weights='imagenet', include_top=False, input_shape=Config.IMAGE_SHAPE)
vgg.trainable = False
outputs = [vgg.get_layer(name).output for name in layer_names]
model = tf.keras.Model(vgg.input, outputs)
return model
def precomputed_vgg19(img_paths):
logging.info('precomputing vgg19 inputs')
vgg = vgg19.VGG19(weights="imagenet", include_top=True)
embeddings = []
for i, (img_path, image_name) in enumerate(img_paths):
img = load_image(img_path) / 255
embedding = calc_vgg_embedding(img, vgg)
embeddings.append({"file_name": image_name, "embedding": embedding})
if (i + 1) % 100 == 0:
print(i + 1)
df = pd.DataFrame(embeddings)
df.to_csv("./precomputed_inputs/vgg19.csv")
def setup_feature_extractor(self):
'''
Method to setup the model that retrieves the intermediate activations of VGG19 (as a dict, by name).
'''
# Build a VGG19 model loaded with pre-trained ImageNet weights
model = vgg19.VGG19(weights="imagenet", include_top=False)
# Get the symbolic outputs of each "key" layer (we gave them unique names).
self.outputs_dict = dict([(layer.name, layer.output)
for layer in model.layers])
# Set up a model that returns the activation values for every layer in
# VGG19 (as a dict).
self.feature_extractor = keras.Model(inputs=model.inputs,
outputs=self.outputs_dict)
def styleTransfer(cData, sData, tData):
print(" Building transfer model.")
contentTensor = K.variable(cData)
styleTensor = K.variable(sData)
genTensor = K.placeholder((1, CONTENT_IMG_H, CONTENT_IMG_W, 3))
inputTensor = K.concatenate([contentTensor, styleTensor, genTensor],
axis=0)
model = vgg19.VGG19(weights="imagenet", include_top=False)
outputDict = dict([(layer.name, layer.output) for layer in model.layers])
print(" VGG19 model loaded.")
loss = 0.0
styleLayerNames = [
"block1_conv1", "block2_conv1", "block3_conv1", "block4_conv1",
"block5_conv1"
]
contentLayerName = "block5_conv2"
feature_extractor = keras.Model(inputs=model.inputs, outputs=outputDict)
features = feature_extractor(inputTensor)
print(" Calculating content loss.")
contentLayer = outputDict[contentLayerName]
contentOutput = contentLayer[0, :, :, :]
genOutput = contentLayer[2, :, :, :]
loss += loss + CONTENT_WEIGHT * contentLoss(contentTensor, genTensor)
print(" Calculating style loss.")
for layerName in styleLayerNames:
layer_features = features[layerName]
style_feature = layer_features[1, :, :, :]
gen_feature = layer_features[2, :, :, :]
style_loss = styleLoss(style_feature, gen_feature)
loss += (STYLE_WEIGHT / len(styleLayerNames)) * style_loss
# TODO: Setup gradients or use K.gradients().
print(" Beginning transfer.")
for i in range(TRANSFER_ROUNDS):
print(" Step %d." % i)
# TODO: perform gradient descent using fmin_l_bfgs_b.
x, min_val, info = scipy.optimize.fmin_l_bfgs_b(
evaluator.loss, x, fprime=evaluator.grads, maxfun=20)
print(" Loss: %f." % tLoss)
img = deprocessImage(x)
saveFile = None # TODO: Implement.
# imsave(saveFile, img) #Uncomment when everything is working right.
print(" Image saved to \"%s\"." % saveFile)
print(" Transfer complete.")
def get_basic_model(input_shape, first_layer=6):
vgg = vgg19.VGG19(weights="imagenet",
include_top=False, input_shape=input_shape)
# or if we want to set the first 20 layers of the network to be non-trainable
index = 1
while index <= first_layer:
layer = vgg.layers[index]
if "conv" in layer.name:
layer.trainable = False
index += 1
else:
index += 1
first_layer += 1
print(layer.name, layer.trainable)
return vgg
def __init__(self, content: np.ndarray, style: np.ndarray):
tf.compat.v1.disable_eager_execution()
K.set_floatx('float64')
self.content = content
self.style = style
print(" Building transfer model.")
self.contentTensor = K.variable(self.content)
self.styleTensor = K.variable(self.style)
self.genTensor = K.placeholder((1, CONTENT_IMG_H, CONTENT_IMG_W, 3))
self.inputTensor = K.concatenate(
[self.contentTensor, self.styleTensor, self.genTensor], axis=0)
self.model = vgg19.VGG19(include_top=False,
input_tensor=self.inputTensor)
self.totalLoss = self.constructTotalLoss()
self.gradient = self.constructGradient()
self.kerasFunction = self.constructKerasFunction()
self.runOutput = None
def init_perception_model():
global perception_model
start = time.time()
with tf.name_scope('Perceptual'):
vgg = vgg19.VGG19(weights='imagenet', include_top=False)
perception_model = Model(inputs=vgg.input,
outputs=[
vgg.get_layer('block1_conv2').output,
vgg.get_layer('block2_conv2').output,
vgg.get_layer('block3_conv2').output,
vgg.get_layer('block4_conv2').output,
vgg.get_layer('block5_conv2').output
])
for layer in perception_model.layers:
layer.trainable = False
print('Loaded perception model:', time.time() - start)
def __init__(self, input_dim, base_image_path, style_reference_image_path,
weights):
self.input_dim = input_dim
self.img_nrows = self.input_dim[0]
self.img_ncols = self.input_dim[1]
self.channels = self.input_dim[2]
self.base_image_path = base_image_path
self.style_reference_image_path = style_reference_image_path
self.content_weight = weights[0]
self.style_weight = weights[1]
self.total_weight = weights[2]
vgg_model = vgg19.VGG19(weights="imagenet", include_top=False)
outputs_dict = dict([(layer.name, layer.output)
for layer in vgg_model.layers])
self.feature_extractor = keras.Model(inputs=vgg_model.inputs,
outputs=outputs_dict)
self._build()
def styleTransfer(cData, sData, tData):
print(" Building transfer model.")
contentTensor = K.variable(cData)
styleTensor = K.variable(sData)
genTensor = K.placeholder((1, CONTENT_IMG_H, CONTENT_IMG_W, 3))
inputTensor = K.concatenate([contentTensor, styleTensor, genTensor], axis=0)
model = vgg19.VGG19(include_top=False, weights="imagenet", input_tensor=inputTensor)
outputDict = dict([(layer.name, layer.output) for layer in model.layers])
print(" VGG19 model loaded.")
loss = 0.0
styleLayerNames = ["block1_conv1", "block2_conv1", "block3_conv1", "block4_conv1", "block5_conv1"]
contentLayerName = "block5_conv2"
print(" Calculating content loss.")
contentLayer = outputDict[contentLayerName]
contentOutput = contentLayer[0, :, :, :]
genOutput = contentLayer[2, :, :, :]
loss += CONTENT_WEIGHT * contentLoss(contentOutput, genOutput)
print(" Calculating style loss.")
for layer_name in styleLayerNames:
layer_features = outputDict[layer_name]
style_reference_features = layer_features[1, :, :, :]
combination_features = layer_features[2, :, :, :]
sl = styleLoss(style_reference_features, combination_features)
loss = loss + (STYLE_WEIGHT / len(styleLayerNames)) * sl
loss += TOTAL_WEIGHT * totalLoss(genTensor)
gradient = K.gradients(loss, genTensor)
outputs = [loss]
if isinstance(gradient, (list, tuple)):
outputs += gradient
else:
outputs.append(gradient)
global f_outputs
f_outputs = K.function([genTensor], outputs)
print(" Beginning transfer.")
evaluator = Evaluator()
for i in range(TRANSFER_ROUNDS):
index = i + 1
print(" Step %d." % i)
tData, tLoss, info = fmin_l_bfgs_b(evaluator.loss, tData.flatten(), fprime=evaluator.grads, maxfun=20)
print(" Loss: %f." % tLoss)
img = deprocessImage(tData.copy())
saveFile = "image" + str(index) + ".jpg"
imageio.imwrite(saveFile, img)
print(" Image saved to \"%s\"." % saveFile)
print(" Transfer complete.")
def run(job_dir,
generator_dir,
discriminator_dir,
content_layers,
real_dataset,
comics_dataset,
comics_edge_blurred_dataset,
learning_rate,
content_weight,
max_steps,
save_summary_steps,
discriminator_training_interval=1):
with tf.summary.create_file_writer(job_dir).as_default():
generator = tf.keras.experimental.load_from_saved_model(
generator_dir,
custom_objects={"InstanceNormalization": InstanceNormalization},
)
generator.summary()
discriminator = tf.keras.experimental.load_from_saved_model(
discriminator_dir,
custom_objects={"InstanceNormalization": InstanceNormalization},
) if discriminator_dir != None else build_discriminator()
discriminator.summary()
vgg = vgg19.VGG19(include_top=False, weights="imagenet")
output_layers = [
vgg.get_layer(layer).output for layer in content_layers
]
loss_net = Model(vgg.input, output_layers, name="loss_net")
train(real_dataset=real_dataset,
comics_dataset=comics_dataset,
comics_edge_blurred_dataset=comics_edge_blurred_dataset,
generator=generator,
discriminator=discriminator,
loss_net=loss_net,
learning_rate=learning_rate,
content_weight=content_weight,
max_steps=max_steps,
save_summary_steps=save_summary_steps,
discriminator_training_interval=discriminator_training_interval)
return generator
def get_model():
"""Creates a model with access to intermediate layers.
These layers will then be used to create a new model that will take the
content image and return the outputs from these intermediate layers from the
VGG model.
Returns:
A keras model that takes image inputs and outputs the style and content
intermediate layers.
"""
vgg = vgg19.VGG19(include_top=False, weights='imagenet')
vgg.trainable = False
style_outputs = [vgg.get_layer(name).output for name in style_layers]
content_outputs = [vgg.get_layer(name).output for name in content_layers]
model_outputs = style_outputs + content_outputs
return models.Model(vgg.input, model_outputs)
def run(job_dir, dataset, content_layers, num_residual_blocks, use_upsampling,
learning_rate, max_steps, save_summary_steps):
with tf.summary.create_file_writer(job_dir).as_default():
vgg = vgg19.VGG19(include_top=False, weights="imagenet")
content_outputs = [vgg.get_layer(l).output for l in content_layers]
loss_net = Model(vgg.input, content_outputs, name="loss_net")
transform_net = build_generator(
num_residual_blocks=num_residual_blocks,
use_upsampling=use_upsampling)
transform_net.summary()
train(dataset=dataset,
transform_net=transform_net,
loss_net=loss_net,
learning_rate=learning_rate,
max_steps=max_steps,
save_summary_steps=save_summary_steps)
return transform_net
def _get_model(input_tensor, model_name="VGG19"):
if model_name == "VGG19":
model = vgg19.VGG19(input_tensor=input_tensor,
include_top=False,
weights="imagenet")
"""
elif model_name == "Xception":
model = Xception(
input_shape=input_shape,
include_top=False,
weights="imagenet"
)
elif model_name == "InceptionV3":
model = InceptionV3(
input_shape=input_shape,
include_top=False,
weights="imagenet"
)
"""
return model
def vgg19Segmentation(n_classes, input_height=224, input_width=224):
img_input = Input(shape=(input_height, input_width, 3))
vgg19_model = vgg19.VGG19(input_tensor=img_input, weights="imagenet")
o = vgg19_model.get_layer('block4_pool').output
o = (ZeroPadding2D((1, 1), data_format='channels_last'))(o)
o = (Conv2D(512, (3, 3), padding='valid', data_format='channels_last'))(o)
o = (BatchNormalization())(o)
o = (UpSampling2D((2, 2), data_format='channels_last'))(o)
o = (ZeroPadding2D((1, 1), data_format='channels_last'))(o)
o = (Conv2D(512, (3, 3), padding='valid', data_format='channels_last'))(o)
o = (BatchNormalization())(o)
o = (UpSampling2D((2, 2), data_format='channels_last'))(o)
o = (ZeroPadding2D((1, 1), data_format='channels_last'))(o)
o = (Conv2D(256, (3, 3), padding='valid', data_format='channels_last'))(o)
o = (BatchNormalization())(o)
o = (UpSampling2D((2, 2), data_format='channels_last'))(o)
o = (ZeroPadding2D((1, 1), data_format='channels_last'))(o)
o = (Conv2D(128, (3, 3), padding='valid', data_format='channels_last'))(o)
o = (BatchNormalization())(o)
o = (UpSampling2D((2, 2), data_format='channels_last'))(o)
o = (ZeroPadding2D((1, 1), data_format='channels_last'))(o)
o = (Conv2D(64, (3, 3), padding='valid', data_format='channels_last'))(o)
o = (BatchNormalization())(o)
o = Conv2D(n_classes, (3, 3), padding='same',
data_format='channels_last')(o)
o = (Activation('softmax'))(o)
model = Model(img_input, o)
return model
def pretrained_VGG(weight_layer_num=16,
side=64,
labels=2,
frozen_layer_num=None,
frozen_block_num=None):
if weight_layer_num == 19:
vgg_ = vgg19.VGG19(weights='imagenet',
input_shape=(side, side, 3),
include_top=False)
block_layer_table = [0, 4, 7, 12, 17, 21]
else:
vgg_ = vgg16.VGG16(weights='imagenet',
input_shape=(side, side, 3),
include_top=False)
block_layer_table = [0, 4, 7, 11, 15, 19]
top_ = Sequential()
top_.add(Flatten(input_shape=vgg_.output_shape[1:]))
top_.add(Dense(1024, activation='relu', kernel_initializer='he_normal'))
top_.add(Dense(1024, activation='relu', kernel_initializer='he_normal'))
top_.add(Dense(labels, activation='softmax'))
model = Model(inputs=vgg_.inputs, outputs=top_(vgg_.outputs))
if frozen_layer_num is None and frozen_block_num is None:
print("No frozen layers: fine-tuning")
return model
if frozen_block_num is not None:
frozen_layer_num = block_layer_table[frozen_block_num]
for layer in vgg_.layers[:frozen_layer_num]:
layer.trainable = False
for i, layer in enumerate(model.layers):
print("layer " + str(i) + " trainable: " + str(layer.trainable))
return model
def create_model(n_out_classes=32, dropout_enable=False):
# # model = mobilenet.MobileNet(input_shape = (256,256,3),
# # classes= n_out_classes,
# # weights=None
# # )
# model = Sequential()
# ##Conv2d Layer
# model.add(Conv2D(64, (3, 3), activation='relu', input_shape=(256, 256, 3),padding="valid"))
# model.add(Activation('relu'))
# ##3x3 pooling
# model.add(BatchNormalization())
# model.add(MaxPooling2D(pool_size=(3, 3)))
# model.add(Activation('relu'))
# model.add(BatchNormalization())
# model.add(Conv2D(32, (3, 3), activation='relu',padding="valid"))
# model.add(Activation('relu'))
# model.add(BatchNormalization())
# model.add(MaxPooling2D(pool_size=(3, 3)))
# model.add(Activation('relu'))
# model.add(BatchNormalization())
#
#
# if dropout_enable:
# model.add(Dropout(0.20))
#
# model.add(Flatten())
#
# model.add(Dense(n_out_classes, activation='softmax'))
model = vgg19.VGG19(
weights="./vgg19_weights_tf_dim_ordering_tf_kernels_notop.h5",
include_top=False,
classes=n_out_classes)
print(model.summary())
return model
