def get_model(input_shape):
model = resnet50.ResNet50(include_top=False, input_shape=input_shape)
mul2 = mul_layer(model.get_layer('activation_40'), model.output)
mul3 = mul_layer(model.get_layer('activation_22'), mul2)
mul4 = mul_layer(model.get_layer('activation_10'), mul3)
mul5 = mul_layer(model.get_layer('activation_1'), mul4)
mul6 = mul_layer(model.get_layer('input_1'), mul5)
output6 = layers.Conv2D(1, (1, 1), activation='sigmoid')(mul6)
return models.Model(inputs=model.inputs, outputs=[output6])
def get_model(input_shape):
model = resnet50.ResNet50(include_top=False, input_shape=input_shape)
output = layers.Conv2D(1, (1, 1), activation='sigmoid')(model.output)
mul2, output2 = mul_layer(model.get_layer('activation_40'), model.output)
mul3, output3 = mul_layer(model.get_layer('activation_22'), mul2)
mul4, output4 = mul_layer(model.get_layer('activation_10'), mul3)
mul5, output5 = mul_layer(model.get_layer('activation_1'), mul4)
return models.Model(
inputs=model.inputs,
outputs=[output5, output4, output3, output2, output])
def create_resNet50_model(self):
"""
Method that builds (but doesn't train) a ResNet50 image model
"""
base_model = resnet50.ResNet50(include_top = False,
weights = 'imagenet',
input_shape = (self.input_dim, self.input_dim, self.image_depth))
reshape_output = Reshape((self.n_image_regions, self.n_image_embed))(base_model.get_layer("activation_48").output)
self.model = Model(inputs=base_model.input, outputs=reshape_output)
self.model.summary()
def __init__(self):
self.root_dir = '/home/stas/dev/demo_projects/dog_breed_classifier'
with open(self._get_dir('resources/dog_names.txt'), 'r') as f:
lines = f.readlines()
self.dog_names = [line.strip() for line in lines]
self.model = self.create_transferred_model()
self.face_cascade = cv2.CascadeClassifier(
self._get_dir('resources/haarcascade_frontalface_alt.xml'))
self.ResNet50_model = r50.ResNet50(weights='imagenet')
self.xcModel = xc.Xception(weights='imagenet', include_top=False)
def build_base_model(self, inputs, **kwarg):
# create the vgg backbone
if self.backbone_name == 'resnet50':
inputs = keras.layers.Lambda(
lambda x: keras_resnet50.preprocess_input(x))(inputs)
resnet = keras_resnet50.ResNet50(input_tensor=inputs,
include_top=False,
weights=None)
else:
raise ValueError("Backbone '{}' not recognized.".format(
self.backbone_name))
return resnet
def load_model(model_name):
if model_name == 'vgg':
#Load the VGG model
model = vgg16.VGG16(weights='imagenet')
#Load the Inception_V3 model
#inception_model = inception_v3.InceptionV3(weights='imagenet')
#Load the ResNet50 model
if model_name == 'resnet50':
model = resnet50.ResNet50(weights='imagenet')
#Load the MobileNet model
if model_name == 'mobilenet':
mobilenet_model = mobilenet.MobileNet(weights='imagenet')
return model
def resnet50_classificator(self, image_path):
resnet_model = resnet50.ResNet50(weights='imagenet')
filename = image_path
original = load_img(filename, target_size=(WIDTH, HEIGHT))
plt.imshow(original)
numpy_image = img_to_array(original)
plt.imshow(np.uint8(numpy_image))
image_batch = np.expand_dims(numpy_image, axis=0)
plt.imshow(np.uint8(image_batch[0]))
processed_image = resnet50.preprocess_input(image_batch.copy())
predictions = resnet_model.predict(processed_image)
label = decode_predictions(predictions)
return sorted(label[0], key=lambda x: x[2], reverse=True)
def get_model(input_shape, num_classes):
model = resnet50.ResNet50(include_top=False, input_shape=input_shape)
mul2 = mul_layer(model.get_layer('activation_40'), model.output)
mul3 = mul_layer(model.get_layer('activation_22'), mul2)
mul4 = mul_layer(model.get_layer('activation_10'), mul3)
mul5 = mul_layer(model.get_layer('activation_1'), mul4)
mul6 = mul_layer(model.get_layer('input_1'), mul5)
output7 = layers.Conv2D(1, (1, 1), activation='linear')(mul6)
output7 = layers.BatchNormalization()(output7)
return models.Model(inputs=model.inputs, outputs=output7)
def build(inputs, output_dims, model_name):
'''
A factory function to create models.
Args:
inputs: input variable.
output_dims(int): number of classes.
model_name(str): model name.
Return:
An instance of the model.
'''
# return vgg16.VGG16(inputs, output_dims)
return resnet50.ResNet50(inputs, output_dims)
def resnet_classifier(in_shape=(256, 256, 3)):
model = resnet50.ResNet50(weights='imagenet',
include_top=False,
input_shape=in_shape)
flatten = Flatten()
new_layer2 = Dense(2, activation='softmax', name='my_dense_2')
inp2 = model.input
out2 = new_layer2(flatten(model.output))
model = Model(inp2, out2)
model.summary(line_length=150)
model.compile(loss='categorical_crossentropy',
optimizer=Adam(lr=0.0002, beta_1=0.5),
metrics=['accuracy'])
return model
def keras_pretrained_model(netname):
#import pdb; pdb.set_trace()
if netname == 'VGG16':
model = vgg16.VGG16(weights='imagenet')
elif netname == 'VGG19':
model = vgg19.VGG19(weights='imagenet')
elif netname == 'ResNet50':
model = resnet50.ResNet50(weights='imagenet')
elif netname == 'DenseNet':
model = densenet.DenseNet121(weights='imagenet')
elif netname == 'Inception_v3':
model = inception_v3.InceptionV3(weights='imagenet')
return _maybe_save(netname, model)
def load_resnet50_model():
"""Instantiate the keras Resnet50 convolutional neural network
Returns
-------
keras.applications.resnet50.Resnet50
Resnet50 CNN with weights trained on imagenet
"""
clear_session()
resnet50_model = resnet50.ResNet50(weights="imagenet")
global resnet50_graph
resnet50_graph = tf.get_default_graph()
return resnet50_model
def main(args):
if args.model == "resnet50":
model = resnet50.ResNet50(include_top=False, input_shape=(224, 224, 3))
image_size = 224
dataset = utils.get_data(args.data_path)
image_paths, labels = utils.get_image_paths_and_labels(dataset)
images = utils.load_images(image_paths, image_size)
last_output = model.predict(images)
with open(args.model + "_" + args.set + ".pkl", "wb") as outfile:
pickle.dump((last_output, labels), outfile)
return
def model_selector(model_name, weights=True):
model = ModelMock()
if model_name == 'vgg_like' or model_name == 'hinton':
if model_name == 'vgg_like':
model_class = cifar10.Vgg_like()
logger.debug("Model: vgg_like")
else:
model_class = cifar10.Hinton()
logger.debug("Model: hinton")
model = model_class.build((32, 32, 3))
if weights:
model.load_weights('data/' + model_class.name + '.h5')
logger.debug("Load weights: success.")
else:
if model_name == 'vgg16':
logger.debug("Model: vgg16")
if weights:
model = vgg16.VGG16(weights='data/vgg16_retraining.h5')
logger.debug("Load weights: success.")
else:
model = vgg16.VGG16(weights=None)
elif model_name == 'resnet50':
logger.debug("Model: resnet50")
if weights:
model = resnet50.ResNet50(
weights='data/resnet50_retraining.h5')
logger.debug("Load weights: success")
else:
model = resnet50.ResNet50(weights=None)
elif model_name == 'mnist':
model_class = mnist.Mnist()
logger.debug("Model: MNIST")
model = model_class.build()
if weights:
model.load_weights('data/' + model_class.name + '.h5')
logger.debug("Load weights: success.")
return model
def build_ripped_resnet50(output_classes_count, trainable_layers, name,
input_shape):
m = resnet50.ResNet50(include_top=False, input_shape=input_shape)
x = GlobalAveragePooling2D(name="tail_avg_pool")(m.output)
x = Dense(output_classes_count, name="tail_fc_final",
activation='softmax')(x)
result = Model(m.input, x, name=name)
for layer in result.layers:
if not is_trainable_layer(trainable_layers, layer):
layer.trainable = False
return result
def _resnet(num_classes, pretrained=True, freezed=True):
weights = 'imagenet' if pretrained else None
base_model = resnet50.ResNet50(input_shape=(224, 224, 3),
weights=weights,
include_top=False)
x = base_model.output
x = layers.Flatten()(x)
predictions = layers.Dense(num_classes,
activation=activations.softmax,
name='predictions')(x)
if freezed:
for layer in base_model.layers:
layer.trainable = False
model = models.Model(inputs=base_model.input, outputs=predictions)
return model
def _setup_model(self):
"""setup ResNet50
Returns: TODO
"""
model_input = keras.layers.Input(self._input_shape)
base_model = resnet50.ResNet50(input_tensor=model_input,
include_top=False)
x = base_model.output
x = keras.layers.Flatten()(x)
x = keras.layers.Dense(self._num_classes,
activation='softmax',
name='global_cls')(x)
model = keras.models.Model(inputs=base_model.input, outputs=x)
return model
def e2e_network():
inception_1 = resnet50.ResNet50(weights="imagenet", include_top=True)
inception_2 = resnet50.ResNet50(weights="imagenet", include_top=True)
for layer in inception_1.layers:
layer.trainable = False
layer.name = layer.name + "_1"
for layer in inception_2.layers:
layer.trainable = False
layer.name = layer.name + "_2"
vector_1 = inception_1.get_layer("avg_pool_1").output
vector_2 = inception_2.get_layer("avg_pool_2").output
sim_head = models.load_model(os.path.join(DATA_DIR, "models", "resnet-dot-best.h5"))
for layer in sim_head.layers:
print(layer.name, layer.input_shape, layer.output_shape)
prediction = sim_head([vector_1, vector_2])
model = models.Model(inputs=[inception_1.input, inception_2.input], outputs=prediction)
model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["accuracy"])
return model
def get_model(input_shape, num_classes):
model = resnet50.ResNet50(include_top=False, input_shape=input_shape)
mul2 = mul_layer(model.get_layer('activation_40'), model.output)
mul3 = mul_layer(model.get_layer('activation_22'), mul2)
mul4 = mul_layer(model.get_layer('activation_10'), mul3)
mul5 = mul_layer(model.get_layer('activation_1'), mul4)
mul6 = mul_layer(model.get_layer('input_1'), mul5)
output7 = [
layers.Conv2D(1, (1, 1), activation='sigmoid')(mul6)
for i in range(0, num_classes)
]
return models.Model(inputs=model.inputs, outputs=output7)
def create_keras_model(output_path):
base = resnet50.ResNet50(include_top=False,
weights="imagenet",
input_shape=(225, 225, 3))
X = base.output
X = GlobalAveragePooling2D()(X)
X = Dropout(0.5)(X)
X = Dense(2, activation='softmax')(X)
model = Model(inputs=base.input, outputs=X)
model.compile(loss='categorical_crossentropy',
optimizer=optimizers.Adam(lr=0.001, clipnorm=1.),
metrics=['accuracy'])
model.save(output_path)
def build_resnet50_model():
# get the model without the denses
base_model = resnet50.ResNet50(weights='imagenet', include_top='false')
new_dense = base_model.output
# add the new denses to classify the hate images
new_dense = Dense(1024, activation='relu')(new_dense)
predictions = Dense(2, activation='softmax')(new_dense)
model = Model(inputs=base_model.input, outputs=predictions)
# we will only train the new denses for the baseline
for layer in base_model.layers:
layer.trainable = False
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=["accuracy"])
return model
def classification_model(number_classes):
#Load the MobileNet model
image_size = 224
resnet = resnet50.ResNet50(weights='imagenet',
include_top=False,
input_shape=(image_size, image_size, 3),
pooling='avg')
#build model
inp = layers.Input(shape=(image_size, image_size, 3))
x = resnet(inp)
z = layers.Dense(number_classes, activation='softmax')(x)
model = models.Model(inp, z)
return model
def regression_model():
#Load the MobileNet model
image_size = 224
resnet = resnet50.ResNet50(weights='imagenet',
include_top=False,
input_shape=(image_size, image_size, 3),
pooling='avg')
#build model
inp = layers.Input(shape=(image_size, image_size, 3))
x = resnet(inp)
z = layers.Dense(2, activation='sigmoid')(x)
model = models.Model(inp, z)
return model
def getModel(net_settings, num_classes=1):
'''
Should be modified with model type as input and returns the desired model
'''
if net_settings['model_type'] == 'resnet':
base_model = resnet50.ResNet50(include_top=True, weights='imagenet')
finetuning = Dense(1, activation='sigmoid',
name='predictions')(base_model.layers[-2].output)
model = Model(input=base_model.input, output=finetuning)
## Adjust learning rate based on number of GPUs
hv_lr = net_settings['lr'] * hvd.size()
opt = optimizers.SGD(lr=hv_lr, momentum=0.9, decay=1e-6, nesterov=True)
## Adding Horovod DistributedOptimizer
opt = hvd.DistributedOptimizer(opt)
model.compile(loss=net_settings['loss'],
optimizer=opt,
metrics=['accuracy'])
callbacks = [
hvd.callbacks.BroadcastGlobalVariablesCallback(0),
]
if hvd.rank() == 0:
callbacks.append(
keras.callbacks.ModelCheckpoint('./checkpoint-{epoch}.h5'))
return model
elif net_settings['model_type'] == 'resnet101':
model = resnet101_model(224, 224, 3, 1)
## Adjust learning rate based on number of GPUs
hv_lr = net_settings['lr'] * hvd.size()
opt = optimizers.SGD(lr=hv_lr, momentum=0.9, decay=1e-6, nesterov=True)
## Adding Horovod DistributedOptimizer
opt = hvd.DistributedOptimizer(opt)
model.compile(loss=net_settings['loss'],
optimizer=opt,
metrics=['accuracy'])
callbacks = [
hvd.callbacks.BroadcastGlobalVariablesCallback(0),
]
if hvd.rank() == 0:
callbacks.append(
keras.callbacks.ModelCheckpoint('./checkpoint-{epoch}.h5'))
return model
else:
print '[models] Ugggh. Not ready for this yet.'
exit(0)
return None
def load_resnet(finetune):
'''Load in the pre-trained Resnet50 model'''
resnet_model = resnet50.ResNet50(weights='imagenet', include_top=False,\
input_shape=(268, 182, 3))
resnet_model.summary()
if not finetune:
return resnet_model
#Add in last layer.
link = resnet_model.output
link = GlobalAveragePooling2D()(link)
predictions = Dense(26, activation='sigmoid')(link)
model = Model(inputs=resnet_model.input, outputs=predictions)
#Freeze all but the last specified layers.
for layer in model.layers[:-10]:
layer.trainable = False
return model
def create_model(img_size, model_type, base_name):
if model_type == 0:
print("Creating MobileNet model")
base = mobilenet.MobileNet(input_shape=img_size,
include_top=False,
weights='imagenet')
elif model_type == 1:
print("Creating InceptionV3 model")
base = inception_v3.InceptionV3(input_shape=img_size,
include_top=False,
weights='imagenet')
elif model_type == 2:
print("Creating Resnet50 model")
base = resnet50.ResNet50(input_shape=img_size,
include_top=False,
weights='imagenet')
elif model_type == 3:
print("Creating InceptionResNet-V2 model")
base = inception_resnet_v2.InceptionResNetV2(input_shape=img_size,
include_top=False,
weights='imagenet')
top = base.output
top = GlobalAveragePooling2D()(top)
top = Dense(units=2048,
activation='relu',
kernel_regularizer=None,
name='fc_1')(top)
predictions = Dense(units=n_classes,
activation='softmax',
kernel_regularizer=l2(l=wd),
name='softmax')(top)
model_combined = Model(inputs=base.input,
outputs=predictions,
name=base_name)
path_to_weights = 'weights/' + weights_filename
model_combined.load_weights(filepath=path_to_weights, by_name=True)
print('Loading weights from ' + path_to_weights)
return model_combined
def resnet(self):
"""Build the structure of a convolutional neural network from input
image data to the last hidden layer on a similar manner than ResNet
See: He, Zhang, Ren, Sun. Deep Residual Learning for Image
Recognition. ArXiv technical report, 2015.
Returns
-------
tensor
(batch_size, nb_labels)-shaped output predictions, that have to be
compared with ground-truth values
"""
resnet_model = resnet50.ResNet50(include_top=False,
input_tensor=self.X)
y = self.flatten(resnet_model.output)
return self.output_layer(y, depth=self.nb_labels)
def model_construction(self, learning_rate):
resnet = resnet50.ResNet50(include_top=False,
weights='imagenet',
input_shape=(224, 224, 3),
pooling='max')
for layer in resnet.layers[:-5]:
layer.trainable = False
self.model.add(resnet)
self.model.add(Dense(10, activation="softmax"))
sgd = SGD(lr=learning_rate, decay=1e-6, momentum=0.9, nesterov=True)
self.model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=sgd,
metrics=['accuracy'])
self.model.summary()
def reid_net(base_model='vgg16', include_top=True, input_shape=None):
if base_model is 'vgg16':
vgg = vgg16.VGG16(include_top=True,
weights='imagenet',
input_shape=input_shape)
#x = vgg.output
#x = Flatten(name='flatten')(x)
#x = Dense(1024, activation = 'relu', name='fc1')(x)
#x = Dense(1024, activation = 'relu', name='fc2')(x)
base_model = Model(vgg.input,
vgg.get_layer('fc2').output,
name='base_model')
elif base_model is 'inception':
inception = inception_v3.InceptionV3(include_top=True,
weights='imagenet')
base_model = Model(
inputs=inception.input,
outputs=inception.get_layer('avg_pool').output,
)
elif base_model is 'resnet50':
resnet = resnet50.ResNet50(include_top=True, weights='imagenet')
base_model = Model(inputs=resnet.input,
outputs=resnet.layers[-2].output,
name='base_model')
elif base_model is 'xception':
model = xception.Xception(weights='imagenet')
base_model = Model(inputs=model.input,
outputs=model.layers[-1].input,
name='base_model')
drop_f = Dropout(0.1, name='drop_f')
cls_out = Dense(751, activation='softmax', name='y_clss')
input1 = Input(shape=input_shape, name='input1')
input2 = Input(shape=input_shape, name='input2')
fea1, fea2 = base_model(input1), base_model(input2)
if not include_top:
model = Model(input1, fea1)
return model
cls1, cls2 = cls_out(fea1), cls_out(fea2)
distance = Lambda(euclidean_distance,
output_shape=eucl_dist_output_shape,
name='distance')([fea1, fea2])
#drop_d = Dropout(0.1,name='drop_d')(distance)
diff_out = Dense(2, activation='softmax', name='y_diff')(distance)
model = Model(inputs=[input1, input2], outputs=[diff_out, cls1, cls2])
return model
def get_model(exp_id):
basedir = os.path.abspath(os.path.dirname(__file__))
exp_model_dict = {
'lenet1': 'model/LeNet-1.h5',
'lenet4': 'model/LeNet-4.h5',
'lenet5': 'model/LeNet-5.h5',
'mutant1': 'model/mutant1.h5',
'mutant2': 'model/mutant2.h5',
'mutant3': 'model/mutant3.h5',
'cifar10': 'model/model_cifar10.h5',
'cifar100': 'model/model_cifar100.h5',
'svhn': 'model/model_svhn.hdf5',
'fashion': 'model/model_fashion.hdf5',
'traffic_sign': "model/model_squeezeNet_TSR.hdf5",
'adv_mnist': 'model/LeNet-5.h5',
'adv_cifar10': 'model/model_cifar10.h5',
'adv_fashion': 'model/model_fashion.hdf5',
'adv_svhn': 'model/model_svhn.hdf5',
'combined_cifar10': 'model/model_cifar10.h5',
'combined_fashion': 'model/model_fashion.hdf5',
'combined_svhn': 'model/model_svhn.hdf5',
'vgg16': 'model/cifar10-vgg16_model_alllayers.h5',
'catvsdog': 'model/cats_and_dogs_small_1.h5'
}
if exp_id == 'vgg19':
my_model = vgg19.VGG19(weights='imagenet')
adam = keras.optimizers.Adagrad(lr=0.01, epsilon=None, decay=0.0)
my_model.compile(loss='categorical_crossentropy',
optimizer=adam,
metrics=['accuracy'])
elif exp_id == 'resnet50':
my_model = resnet50.ResNet50(weights='imagenet')
adam = keras.optimizers.Adagrad(lr=0.01, epsilon=None, decay=0.0)
my_model.compile(loss='categorical_crossentropy',
optimizer=adam,
metrics=['accuracy'])
elif exp_id in exp_model_dict.keys():
my_model = keras.models.load_model(
os.path.join(basedir, exp_model_dict[exp_id]))
else:
raise Exception("no such dataset found: {}".format(exp_id))
return my_model
