def xception_retinanet(num_classes,
backbone='xception',
inputs=None,
modifier=None,
**kwargs):
k.clear_session()
# choose default input
if inputs is None:
if keras.backend.image_data_format() == 'channels_first':
inputs = keras.layers.Input(shape=(3, None, None))
else:
inputs = keras.layers.Input(shape=(None, None, 3))
# create the resnet backbone
if backbone == 'xception':
xception_model = Xception(weights='imagenet',
include_top=False,
input_tensor=inputs)
else:
raise ValueError('Backbone (\'{}\') is invalid.'.format(backbone))
# invoke modifier if given
if modifier:
xception_model = modifier(xception_model)
concatenated_features = [
xception_model.get_layer("add_7").output,
xception_model.get_layer("add_10").output, xception_model.output
]
# create the full model
return retinanet.retinanet(inputs=inputs,
num_classes=num_classes,
backbone_layers=concatenated_features,
**kwargs)
def save_model3(new_model_path, conv_model_path):
model = Xception(
input_shape=(img_width, img_height, 3),
include_top=False,
weights=None
)
if pretrained:
model = Xception(
input_shape=(img_width, img_height, 3),
include_top=False,
weights='imagenet'
)
transfer_layer = model.get_layer('block14_sepconv2_act')
conv_model = Model(inputs=model.input,
outputs=transfer_layer.output)
new_model = Sequential()
new_model.add(conv_model)
new_model.add(GlobalAveragePooling2D())
if num_fc_layers>=1:
new_model.add(Dense(num_fc_neurons, activation='relu'))
if num_fc_layers>=2:
new_model.add(Dropout(dropout))
new_model.add(Dense(num_fc_neurons, activation='relu'))
if num_fc_layers>=3:
new_model.add(Dropout(dropout))
new_model.add(Dense(num_fc_neurons, activation='relu'))
new_model.add(Dense(num_classes, activation='softmax'))
print(new_model.summary())
new_model.save(new_model_path)
conv_model.save(conv_model_path)
def xcpt(input_shape=None, channels=2, lr=1e-4, weights=None, classes=4, **kwargs):
input_shape_xception = (None, None, 3) if K.image_data_format() == 'channels_last' else (3, None, None)
xception_model = Xception(input_shape=input_shape_xception, include_top=False, weights='imagenet')
xception_model = Model(xception_model.input, xception_model.get_layer('block13_sepconv2_bn').output)
if input_shape is None:
if K.image_data_format() == 'channels_last':
input_shape = (None, None, channels)
else:
input_shape = (channels, None, None)
main_input = Input(input_shape)
x = Convolution2D(3, (1, 1), kernel_initializer=kernel_initializer)(main_input)
x = xception_model(x)
x = GlobalAveragePooling2D(name='pool1')(x)
main_output = Dense(classes, activation='softmax', name='predictions')(x)
# Create model.
model = Model(main_input, main_output, name='xcpt')
if weights is not None:
print('Load weights from', weights)
model.load_weights(weights)
optimizer = SGD(lr, momentum=0.95, decay=0.0005, nesterov=True)
model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])
return model
def get_model_xception_pretrained(input_shape=(75, 75, 3), inputs_meta=1):
dropout = 0.25
optimizer = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
#Building the model
base_model = Xception(weights='imagenet', include_top=False,
input_shape=input_shape, classes=1)
input_meta = Input(shape=[inputs_meta], name='meta')
input_meta_norm = BatchNormalization()(input_meta)
x = base_model.get_layer('block14_sepconv2_act').output
x = GlobalMaxPooling2D()(x)
concat = concatenate([x, input_meta_norm], name='features_layer')
fc1 = Dense(512, activation='relu', name='fc2')(concat)
fc1 = Dropout(dropout)(fc1)
fc2 = Dense(256, activation='relu', name='fc3')(fc1)
fc2 = Dropout(dropout)(fc2)
# Sigmoid Layer
output = Dense(1)(fc2)
output = Activation('sigmoid')(output)
model = Model(inputs=[base_model.input, input_meta], outputs=output)
model.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['accuracy'])
return model
def create_model(input_shape, n_out):
input_tensor = Input(shape=(SIZE, SIZE, 3))
#bn = BatchNormalization()(input_tensor)
#conv = Conv2D(3,(3,3),padding='same',activation='relu')(bn)
base_model = Xception(include_top=False,
weights='imagenet',
input_shape=(SIZE, SIZE, 3),
input_tensor=input_tensor)
x = base_model.get_layer('block13_sepconv2_bn').output
#x = Dropout(0.5)(x)
x_map32 = Conv2D(28,
kernel_size=(1, 1),
activation='sigmoid',
name='map32')(x)
x_pooled = NoisyAndPooling2D()(x_map32)
output = Dense(28, activation='sigmoid', name='pred')(x_pooled)
model = Model(input_tensor, [output, x_map32])
# transfer imagenet weights
#res_img = ResNet34(include_top=False, weights='imagenet', input_shape=(SIZE, SIZE, 3))
#offset = 2
#for i, l in enumerate(base_model.layers[offset+1:]):
# l.set_weights(res_img.layers[i + 1].get_weights())
return model
def get_model(input_shape=(513, 513, 3),
atrous_rate=(6, 12, 18),
class_no=21,
freezeEncoder=False):
input_tensor = layers.Input(shape=input_shape)
with tf.variable_scope("encoder"):
encoder = Xception(include_top=False,
weights='imagenet',
input_tensor=input_tensor)
x_output = encoder.output
if freezeEncoder:
for layer in encoder.layers: # not available as pre train model is not ready here.
layer.trainable = False
x = Xception_DeepLabV3Plus.get_separable_atrous_conv(
x_output, atrous_rate=atrous_rate)
x = layers.Conv2D(256, (1, 1),
padding='same',
use_bias=False,
name='concat_projection',
kernel_initializer='he_normal')(x)
x = layers.BatchNormalization(name='concat_projection_BN',
epsilon=1e-5)(x)
x = layers.Activation('relu')(x)
x = layers.Dropout(0.1)(x)
with tf.variable_scope("decoder"):
# # x4 (x2) block
skip1 = encoder.get_layer('block3_sepconv2_bn').output
x = BilinearResizeLayer2D(target_size=(K.int_shape(skip1)[1],
K.int_shape(skip1)[2]),
name='UpSampling1')(x)
dec_skip1 = layers.Conv2D(48, (1, 1),
padding='same',
use_bias=False,
name='feature_projection0',
kernel_initializer='he_normal')(skip1)
dec_skip1 = layers.BatchNormalization(
name='feature_projection0_BN', epsilon=1e-5)(dec_skip1)
dec_skip1 = layers.Activation('relu')(dec_skip1)
x = layers.Concatenate()([x, dec_skip1])
x = layers.Conv2D(class_no, (1, 1),
padding='same',
kernel_initializer='he_normal')(x)
x = BilinearResizeLayer2D(
target_size=K.int_shape(input_tensor)[1:3],
name='UpSampling2')(x)
x = layers.Activation('softmax')(x)
model = models.Model(inputs=input_tensor,
outputs=x,
name='deeplab_try')
return model
def xception_globalavgpool():
Xception_notop = Xception(include_top=False, weights='imagenet',
input_tensor=None, input_shape = size)
output = Xception_notop.get_layer(index = -1).output
output = GlobalAveragePooling2D()(output)
output = Dense(3, activation='softmax', name='predictions')(output)
Xception_model = Model(Xception_notop.input, output)
Xception_model.compile(loss='categorical_crossentropy', optimizer = optimizer, metrics = ['accuracy'])
return Xception_model
def create_feature_sub_nn(self, feature):
input_name = '%s_input' % feature['name']
image_size = self.model_parameters.get_image_size(feature)
(width, height, depth) = image_size
cnn = self.model_parameters.get_cnn(feature)
if cnn == "xception":
raise NotImplementedError()
# TODO: not tested
base_model = Xception(weights='imagenet')
# base_model.summary()
for i, layer in enumerate(base_model.layers):
layer.name = '%s_%s' % (feature['name'], layer.name)
layer.trainable = i > 63
# total: 126
# Setting layer name: https://github.com/keras-team/keras/issues/6194
base_model.layers[0].name = input_name
input = base_model.input
output = base_model.get_layer('avg_pool').output # avg_pool might not exists ...
output = Flatten()(output)
return input, output
elif cnn == "mobilenet":
base_model = MobileNet(
include_top=False,
weights='imagenet',
input_tensor=Input(shape=image_size),
input_shape=image_size
)
# base_model.summary()
# Rename layers to avoid conflicts
for i, layer in enumerate(base_model.layers):
layer.name = '%s_%s' % (feature['name'], layer.name)
# Get input and output
base_model.layers[0].name = input_name
input = base_model.input
output = base_model.layers[-6].output
output = Flatten()(output)
# We only train the last layers (total: 88)
for i, layer in enumerate(base_model.layers):
layer.trainable = i > 50
return input, output
elif cnn == 'small':
return self.create_standard_cnn(input_name, width, height, depth, 2)
elif cnn == 'medium':
return self.create_standard_cnn(input_name, width, height, depth, 3)
elif cnn == 'large':
return self.create_standard_cnn(input_name, width, height, depth, 4)
else:
raise NotImplementedError('Unsupported ImageNN: %s' % self.model_parameters.cnn)
def xception_encoder(image_size):
encoder = Xception(include_top=False, input_shape=image_size + (3,))
print('Model loaded.')
feature_map_temp = encoder.get_layer('block13_sepconv1_act').output
feature_net = Model(inputs=encoder.input,
outputs=feature_map_temp)
weight_to_monitor = feature_net.get_layer('block12_sepconv2').weights[0][0,0,0,0]
return feature_net, weight_to_monitor
def _build(self, weights):
base_model = Xception(include_top=False, weights='imagenet')
x = base_model.layers[105].output
block4_out = base_model.get_layer('block4_sepconv2_bn').output
block4_avg = GlobalAveragePooling2D()(block4_out)
self.block4_dense = Dense(512, name="block4_dense")(block4_avg)
genre_predictions = self._create_block(x, self.num_genres, 'genre')
style_predictions = self._create_block(x, self.num_styles, 'style')
self.model = Model(inputs=base_model.input, outputs=[genre_predictions, style_predictions])
if weights:
self.model.load_weights(weights)
def xception_dense():
notop = Xception(include_top=False, weights='imagenet',
input_tensor=None, input_shape = size)
output = notop.get_layer(index = -1).output
output = Flatten(name='flatten')(output)
output = Dropout(0.2)(output)
output = Dense(512)(output)
output = PReLU()(output)
output = BatchNormalization()(output)
output = Dropout(0.3)(output)
output = Dense(3, activation='softmax', name = 'predictions')(output)
Xception_model = Model(notop.input, output)
Xception_model.compile(loss='categorical_crossentropy', optimizer = optimizer, metrics = ['accuracy'])
return Xception_model
def predict():
img2 = Image.open(filename)
with open('settings/settings.json') as f:
config = json.load(f)
m_name = config["model"]
weights = config["weights"]
include_top = config["include_top"]
train_path = config["train_path"]
test_path = config["test_path"]
deep_features = config["deep_features"]
labels_path = config["labels_path"]
test_size = config["test_size"]
results = config["results"]
model_path = config["model_path"]
seed = config["seed"]
classifier_path = config["classifier_path"]
classifier = pickle.load(open(classifier_path, 'rb'))
classifier = pickle.load(open(classifier_path, 'rb'))
if m_name == "xception":
pre_trained = Xception(weights=weights)
model = Model(pre_trained.input,
pre_trained.get_layer('avg_pool').output)
image_size = (299, 299)
else:
pre_trained = None
train_labels = os.listdir(train_path)
img = img2
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
feature = model.predict(x)
flat = feature.flatten()
flat = np.expand_dims(flat, axis=0)
preds = classifier.predict(flat)
prediction = train_labels[preds[0]]
print("" + train_labels[preds[0]])
x = train_labels[preds[0]].split("#")
x = [item.replace(",", " #") for item in x]
explanation = "Recommended Hashtags:\n #" + " #".join(x)
w2 = tk.Label(main, justify=tk.CENTER, padx=100, text=explanation)
w2.config(font=("Courier", 12, 'bold'), fg="DarkOrchid4")
w2.pack()
def create_bottlenet_features_xception(image_tensor):
from keras.applications.xception import Xception
from keras.applications.xception import preprocess_input as preprocess_input_xception
xception = Xception(weights='imagenet', include_top=False)
#print(xception.summary())
bottleneck_model = Model(inputs=xception.input, outputs=xception.get_layer('block14_sepconv2_act').output)
#print(bottleneck_model.summary())
bottleneck_features = bottleneck_model.predict(preprocess_input_xception(image_tensor))
print(bottleneck_features.shape)
return bottleneck_features
def build_xception():
model = Xception(include_top=False, pooling='max')
output = Dense(128, activation='softmax',
name='predictions')(model.layers[-1].output)
model = Model(inputs=model.layers[0].input, outputs=output)
finetuned_layers_names = ['predictions']
finetuned_layers = [
model.get_layer(name=layer_name)
for layer_name in finetuned_layers_names
]
for layer in model.layers:
if layer not in finetuned_layers:
layer.trainable = False
return model
def perceptual_loss(img_true, img_generated):
image_shape = (600, 600, 3)
xception = Xception(include_top=False,
weights='imagenet',
input_shape=image_shape)
loss_block3 = Model(
inputs=xception.input,
outputs=xception.get_layer('block5_sepconv1_act').output)
loss_block3.trainable = False
#loss_block2 = Model(inputs=xception.input, outputs=xception.get_layer('block2_conv2').output)
#loss_block2.trainable = False
#loss_block1 = Model(input=xception.input, outputs=xception.get_layer('block1_conv2').output)
#loss_block1.trainable = False
#return K.mean(K.square(loss_block1(img_true) - loss_block1(img_generated))) + 2 * K.mean(
# K.square(loss_block2(img_true) - loss_block2(img_generated))) + 5 * K.mean(
# K.square(loss_block3(img_true) - loss_block3(img_generated)))
return K.mean(K.square(loss_block3(img_true) - loss_block3(img_generated)))
def build_2d_net(img_size):
# 输出是96*28*28
base_model = Xception(
include_top=False,
weights='imagenet',
input_shape=(img_size, img_size,
3)) # default input shape is (299, 299, 3)
x = layers.SeparableConv2D(
96, (3, 3), padding='same', use_bias=False, name='block4_sepconv1')(
base_model.get_layer('block4_sepconv1_act').output)
x = layers.BatchNormalization(name='block4_sepconv1_bn')(x)
x = layers.Activation('relu', name='block4_sepconv2_act')(x)
model = Model(inputs=base_model.input, outputs=x)
print(model.summary())
return model
def bisenet_model():
"""
:return:
"""
inputs = Input(shape=Input_size)
x = Lambda(lambda image: preprocess_input(image))(inputs)
xception = Xception(weights='imagenet',
input_shape=Input_size,
include_top=False)
tail_prev = xception.get_layer('block13_pool').output
tail = xception.output
output = final_model(x, tail_prev, tail)
# inputs, xception_inputs, ans = get_model()
model = Model(inputs=[inputs, xception.input], output=[output])
return model
def __init__(self):
base_model = VGG16(weights='imagenet')
self.model_fc1 = Model(inputs=base_model.input,
outputs=base_model.get_layer('fc1').output
)
self.model_fc2 = Model(inputs=base_model.input,
outputs=base_model.get_layer('fc2').output
)
v3base_model = InceptionV3(weights='imagenet')
self.model_v3 = Model(inputs=v3base_model.input,
outputs=v3base_model.get_layer('avg_pool').output
)
# avg_pool (GlobalAveragePooling2 (None, 2048) block14_sepconv2_act[0][0]
xbase_model = Xception(weights='imagenet')
self.model_x = Model(input=xbase_model.input,
outputs=xbase_model.get_layer('avg_pool').output
)
def model_Xception():
input_2 = Input(shape=[1], name="angle")
angle_layer = Dense(1, )(input_2)
base_model = Xception(weights='imagenet', include_top=False,input_shape=X_train.shape[1:], classes=1)
x = base_model.get_layer('block4_pool').output
x = GlobalAveragePooling2D()(x)
#x = Flatten()(x)
merge_one = concatenate([x, angle_layer])
merge_one = Dense(512, activation='relu', name='fc2')(merge_one)
merge_one = Dropout(0.3)(merge_one)
merge_one = Dense(512, activation='relu', name='fc3')(merge_one)
merge_one = Dropout(0.3)(merge_one)
predictions = Dense(1, activation='sigmoid')(merge_one)
model = Model(input=[base_model.input, input_2], output=predictions)
# sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
# model.compile(loss='binary_crossentropy',
# optimizer=sgd,
# metrics=['accuracy'])
return model
def __init__(self,
xes,
y1es,
y2es,
image_net_model_type='vgg',
k=40,
weight=False):
print('k =', k, 'model_type= ', image_net_model_type)
print('setting up model...')
self.keras_model = keras_knn(xes, y1es, y2es, k=k)
print('...done')
self.model_name = 'knn_' + image_net_model_type
self.weight = weight
if weight:
self.model_name = self.model_name + '_weight'
self.image_net_model_type = image_net_model_type
self.xes = xes.T
self.y1es = y1es
self.y2es = y2es
if image_net_model_type == 'vgg':
base_vgg_model = VGG16(weights='imagenet')
self.image_net_model = keras.models.Model(
inputs=base_vgg_model.input,
outputs=base_vgg_model.get_layer('fc1').output)
elif image_net_model_type == 'resnet':
self.image_net_model = ResNet50(include_top=False,
weights='imagenet')
elif image_net_model_type == 'xception':
xception_base_model = Xception(include_top=True,
weights='imagenet')
self.image_net_model = keras.models.Model(
inputs=xception_base_model.input,
outputs=xception_base_model.get_layer('avg_pool').output)
self.input_shape = self.image_net_model.input_shape
print('Finished constructor')
def Make_Model(modelConfig, datasetConfig):
strModelType = modelConfig.MODEL_TYPE
strPretrained = modelConfig.PRETRAINED_MODEL
im_Shape = datasetConfig.IMG_SHAPE
strOptimizer = modelConfig.OPTIMIZER
num_Classes = datasetConfig.NUM_CLASS
learingRate = modelConfig.LEARNING_RATE
decay = modelConfig.DECAY
momentum = modelConfig.MOMENTUM
loss = modelConfig.LOSS
optimizer = None
if (strOptimizer == "SGD"):
optimizer = SGD(lr=learingRate,
decay=decay,
momentum=momentum,
nesterov=True) # decay = 1e-4
elif (strOptimizer == "ADAM"):
optimizer = Adam(lr=learingRate, decay=decay)
else:
print("No Such a Optimizer")
return None
model = None
Num = 2
if (strModelType == "VGG16"):
model = VGG16(weights=strPretrained,
include_top=False,
input_shape=im_Shape,
classes=Num)
elif (strModelType == "RESNET50"):
model = ResNet50(weights=strPretrained,
include_top=True,
input_shape=im_Shape,
classes=Num)
elif (strModelType == "RESNET152"):
model = build_Resnet152_Model(im_Shape, Num, strPretrained)
elif (strModelType == "INCEPTIONV3"):
model = InceptionV3(weights=strPretrained,
include_top=True,
input_shape=im_Shape,
classes=Num)
elif (strModelType == "INCEPTIONRESV2"):
model = InceptionResNetV2(weights=strPretrained,
include_top=True,
input_shape=im_Shape,
classes=Num)
elif (strModelType == "SEINCEPTIONRESV2"):
model = SEInceptionResNetV2(weights=strPretrained,
include_top=True,
input_shape=im_Shape,
classes=Num)
elif (strModelType == "XCEPTION"):
model = Xception(weights=strPretrained,
include_top=True,
input_shape=im_Shape,
classes=Num)
#basemodel = Xception(weights="imagenet", include_top=True, input_shape=(299,299,3), classes = 1000)
#x = Dense(num_Classes, activation='softmax', name='predictions')(basemodel.layers[-2].output)
#model = Model(basemodel.input, x)
elif (strModelType == "UNET2D"):
model = build_UNet2D_4L(im_Shape, strPretrained)
elif (strModelType == "CNN6Layers"):
model = build_CNN_6layers(im_Shape, num_classes=num_Classes)
else:
print("No Such Model Type")
return None
# for layer in model.layers[:-15] :
# layer.trainable = False
# oldlayer = model.layers.pop(-1)
# model.layers.pop(-1)
x_xc = model.get_layer(index=-2).output
#print(x_xc.output_shape)
# print(x_xc.shape)
#x_xc = GlobalMaxPooling2D()(x_xc)
out = Dense(int(num_Classes), activation='softmax', name='pp')(x_xc)
model = Model(input=model.input, output=out)
# upperlayer = model.layers[-2]
# output = Dense(int(num_Classes), activation='softmax')(upperlayer)
#model.trainable = False
#model = model (input = model.layers[0], output = output)
model.compile(optimizer=optimizer, loss=loss, metrics=['accuracy'])
model.summary()
return model
from keras.optimizers import Adam
from keras import layers
from keras import Model
pre_model = Xception(weights=None,
input_shape=(150, 150, 3),
include_top=False)
pre_weights = 'C:/Users/hp/Desktop/pneumonia/xception_weights_tf_dim_ordering_tf_kernels_notop.h5'
pre_model.load_weights(pre_weights)
for layer in pre_model.layers:
layer.trainable = False
last_layer = pre_model.get_layer('block4_pool')
last_output = last_layer.output
x = layers.AveragePooling2D(7, 7)(last_output)
x = layers.Flatten()(x)
x = layers.Dense(1024, activation='relu')(x)
x = layers.Dropout(0.5)(x)
x = layers.Dense(512, activation='relu')(x)
x = layers.Dropout(0.4)(x)
x = layers.Dense(1, activation='sigmoid')(x)
model = Model(pre_model.input, x)
model.compile(optimizer=Adam(lr=0.0001),
loss='binary_crossentropy',
metrics=['accuracy'])
def main():
# Parameters
if len(sys.argv) == 3:
superclass = sys.argv[1]
model_weight = sys.argv[2]
else:
print('Parameters error')
exit()
# The constants
classNum = {'A': 40, 'F': 40, 'V': 40, 'E': 40, 'H': 24}
testName = {'A': 'a', 'F': 'a', 'V': 'b', 'E': 'b', 'H': 'b'}
date = '20180321'
# Feature extraction model
base_model = Xception(include_top=True,
weights=None,
input_tensor=None,
input_shape=None,
pooling=None,
classes=classNum[superclass[0]])
base_model.load_weights(model_weight)
base_model.summary()
model = Model(inputs=base_model.input,
outputs=base_model.get_layer('avg_pool').output)
imgdir_train = '../zsl_'+testName[superclass[0]]+'_'+str(superclass).lower()+'_train_'+date\
+'/zsl_'+testName[superclass[0]]+'_'+str(superclass).lower()+'_train_images_'+date
imgdir_test = '../zsl_' + testName[superclass[0]] + '_' + str(
superclass).lower() + '_test_' + date
categories = os.listdir(imgdir_train)
categories.append('test')
num = 0
for eachclass in categories:
if eachclass[0] == '.':
continue
if eachclass == 'test':
classpath = imgdir_test
else:
classpath = imgdir_train + '/' + eachclass
num += len(os.listdir(classpath))
print('Total image number = ' + str(num))
features_all = np.ndarray((num, 2048))
labels_all = list()
images_all = list()
idx = 0
# Feature extraction
for iter in tqdm(range(len(categories))):
eachclass = categories[iter]
if eachclass[0] == '.':
continue
if eachclass == 'test':
classpath = imgdir_test
else:
classpath = imgdir_train + '/' + eachclass
imgs = os.listdir(classpath)
for eachimg in imgs:
if eachimg[0] == '.':
continue
img_path = classpath + '/' + eachimg
img = image.load_img(img_path, target_size=(229, 299))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
feature = model.predict(x)
features_all[idx, :] = feature
labels_all.append(eachclass)
images_all.append(eachimg)
idx += 1
features_all = features_all[:idx, :]
labels_all = labels_all[:idx]
images_all = images_all[:idx]
data_all = {
'features_all': features_all,
'labels_all': labels_all,
'images_all': images_all
}
# Save features
savename = 'features_' + superclass + '.pickle'
fsave = open(savename, 'wb')
pickle.dump(data_all, fsave)
fsave.close()
def main():
# Parameters
if len(sys.argv) == 4:
superclass = sys.argv[1]
imgmove = sys.argv[2]
if imgmove == 'False':
imgmove = False
else:
imgmove = True
lr = float(sys.argv[3])
else:
print('Parameters error')
exit()
# The constants
classNum = {'A': 40, 'F': 40, 'V': 40, 'E': 40, 'H': 24}
testName = {'A': 'a', 'F': 'a', 'V': 'b', 'E': 'b', 'H': 'b'}
date = '20180321'
classAttrsNums = {'Animals': 123, 'Fruits': 58, 'Hairstyles':22,'Vehicles':81,'Electronics':75}
classAttrsNum = classAttrsNums[superclass]
trainpath = 'trainval_'+superclass+'/train'
valpath = 'trainval_'+superclass+'/val'
weightname = 'model/mobile_'+superclass+'_wgt_reduced.h5'
if not os.path.exists('model'):
os.mkdir('model')
# Train/validation data preparation
if imgmove:
os.mkdir('trainval_'+superclass)
os.mkdir(trainpath)
os.mkdir(valpath)
sourcepath = '../zsl_'+testName[superclass[0]]+'_'+str(superclass).lower()+'_train_'+date\
+'/zsl_'+testName[superclass[0]]+'_'+str(superclass).lower()+'_train_images_'+date
categories = os.listdir(sourcepath)
for eachclass in categories:
if eachclass[0] == superclass[0]:
print(eachclass)
os.mkdir(trainpath+'/'+eachclass)
os.mkdir(valpath+'/'+eachclass)
imgs = os.listdir(sourcepath+'/'+eachclass)
idx = 0
for im in imgs:
if idx%8 == 0:
shutil.copyfile(sourcepath+'/'+eachclass+
'/'+im, valpath+'/'+eachclass+'/'+im)
else:
shutil.copyfile(sourcepath+'/'+eachclass+
'/'+im, trainpath+'/'+eachclass+'/'+im)
idx += 1
# Train and validation ImageDataGenerator
batchsize = 32
train_datagen = XmanImageDataGenerator(
rescale=1./255,
rotation_range=15,
width_shift_range=5,
height_shift_range=5,
horizontal_flip=True)
test_datagen = XmanImageDataGenerator(rescale=1./255)
train_generator = train_datagen.flow_from_directory(
trainpath,
target_size=(72, 72),
batch_size=batchsize)
valid_generator = test_datagen.flow_from_directory(
valpath,
target_size=(72, 72),
batch_size=batchsize)
# Train Xception
base_model = Xception(include_top=True, weights=None,
input_tensor=None, input_shape=(72,72,3),
pooling=None, classes=classNum[superclass[0]])
output = Dense(classAttrsNum, activation='sigmoid', name='predictions')(base_model.get_layer('avg_pool').output)
model = Model(inputs=base_model.input, outputs=output)
model.summary()
model.compile(optimizer=SGD(lr=lr, momentum=0.9),
loss='binary_crossentropy', metrics=['accuracy'])
steps_per_epoch = int(train_generator.n/batchsize)
validation_steps = int(valid_generator.n/batchsize)
if os.path.exists(weightname):
model.load_weights(weightname)
checkpointer = ModelCheckpoint(weightname, monitor='val_loss', verbose=0,
save_best_only=True, save_weights_only=True, mode='auto', period=1)
model.fit_generator(
train_generator,
steps_per_epoch=steps_per_epoch,
epochs=25,
validation_data=valid_generator,
validation_steps=validation_steps,
callbacks=[checkpointer])
# VGG16_Layer_Before_Last_Layer
elif model_name == "VGG16_Last":
#print(3)
base_model_VGG16 = VGG16(weights='imagenet', include_top=False)
built_model = Model(
inputs=base_model_VGG16.input,
outputs=base_model_VGG16.get_layer('block4_pool').output)
# Xception
elif model_name == "Xception":
#print(4)
model_Xception_base = Xception(weights='imagenet',
pooling='max',
include_top=False)
built_model = Model(
inputs=model_Xception_base.input,
outputs=model_Xception_base.get_layer('block4_pool').output)
product_image = pd.read_csv(file_path, )
file_List = product_image['Product_Image'].tolist()
product_List = product_image['Product_Id'].tolist()
List_product_List = chunks(product_List, 1000)
List_file_List = chunks(file_List, 1000)
jobs = []
# lock = t.Lock()
p = Pool()
#print(built_model)
for product_List, file_List in zip(enumerate(List_product_List),
enumerate(List_file_List)):
#if product_List[0]>6 and file_List[0]>6: #Comment the line
doJob(product_List[0], file_List[1], product_List[1], "Temp",
model_name, built_model)
# check for pretrained weight usage or not / önceden eğitilmiş ağırlık kullanımı olup olmadığının kontrolü
# check for top layers to be included or not / üst katmanların dahil edilip edilmeyeceğinin kararının verilmesi
if model_name == "vgg16":
base_model = VGG16(weights=weights)
model = Model(input=base_model.input,
output=base_model.get_layer('fc1').output)
image_size = (224, 224)
elif model_name == "vgg19":
base_model = VGG19(weights=weights)
model = Model(input=base_model.input,
output=base_model.get_layer('fc1').output)
image_size = (224, 224)
elif model_name == "xception":
base_model = Xception(weights=weights)
model = Model(input=base_model.input,
output=base_model.get_layer('avg_pool').output)
image_size = (299, 299)
else:
base_model = None
print("[INFO] successfully loaded base model and model...")
# path to training dataset / eğitim veriseti yolu
train_labels = os.listdir(train_path)
# encode the labels / etiketlerin kodlanması
print("[INFO] encoding labels...")
le = LabelEncoder()
le.fit([tl for tl in train_labels])
# variables to hold features and labels / özellik ve etiketleri tutması için değişkenlerin tanımlanması
def get_image_features(self, image_directory):
from keras.preprocessing import image
from keras.models import Model
if self.cnn_extractor == 'vgg16':
from keras.applications.vgg16 import preprocess_input
from keras.applications import VGG16
self.IMG_FEATS = 4096
base_model = VGG16(weights='imagenet')
model = Model(inputs=base_model.input,
outputs=base_model.get_layer('fc2').output)
self.extracted_features = []
self.image_feature_files = list(set(self.image_files))
number_of_images = len(self.image_feature_files)
for image_arg, image_file in tqdm(
enumerate(self.image_feature_files)):
image_path = image_directory + image_file
# if image_arg%100 == 0:
# print('%.2f %% completed' %
# round(100*image_arg/number_of_images,2))
img = image.load_img(image_path, target_size=(224, 224))
img = image.img_to_array(img)
img = np.expand_dims(img, axis=0)
img = preprocess_input(img)
CNN_features = model.predict(img)
self.extracted_features.append(np.squeeze(CNN_features))
self.extracted_features = np.asarray(self.extracted_features)
elif self.cnn_extractor == 'vgg19':
from keras.applications.vgg19 import preprocess_input
from keras.applications import VGG19
self.IMG_FEATS = 4096
base_model = VGG19(weights='imagenet')
model = Model(inputs=base_model.input,
outputs=base_model.get_layer('fc2').output)
self.extracted_features = []
self.image_feature_files = list(set(self.image_files))
number_of_images = len(self.image_feature_files)
for image_arg, image_file in enumerate(self.image_feature_files):
image_path = image_directory + image_file
if image_arg % 100 == 0:
print('%.2f %% completed' %
round(100 * image_arg / number_of_images, 2))
img = image.load_img(image_path, target_size=(224, 224))
img = image.img_to_array(img)
img = np.expand_dims(img, axis=0)
img = preprocess_input(img)
CNN_features = model.predict(img)
self.extracted_features.append(np.squeeze(CNN_features))
self.extracted_features = np.asarray(self.extracted_features)
elif self.cnn_extractor == 'inception':
from keras.applications.inception_v3 import preprocess_input
from keras.applications import InceptionV3
self.IMG_FEATS = 2048
base_model = InceptionV3(weights='imagenet')
model = Model(inputs=base_model.input,
outputs=base_model.get_layer('avg_pool').output)
self.extracted_features = []
self.image_feature_files = list(set(self.image_files))
number_of_images = len(self.image_feature_files)
for image_arg, image_file in tqdm(
enumerate(self.image_feature_files)):
image_path = image_directory + image_file
# if image_arg%100 == 0:
# print('%.2f %% completed' %
# round(100*image_arg/number_of_images,2))
img = image.load_img(image_path, target_size=(299, 299))
img = image.img_to_array(img)
img = np.expand_dims(img, axis=0)
img = preprocess_input(img)
CNN_features = model.predict(img)
self.extracted_features.append(np.squeeze(CNN_features))
self.extracted_features = np.asarray(self.extracted_features)
elif self.cnn_extractor == 'vgg16_places':
from VGG_Place205 import VGG16_places
from keras.applications.vgg16 import preprocess_input
self.IMG_FEATS = 4096
base_model = VGG16_places()
base_model.load_weights(
"VGG_Place205/vgg_tensorflow_channels_last.h5")
model = Model(inputs=base_model.input,
outputs=base_model.get_layer('fc7').output)
self.extracted_features = []
self.image_feature_files = list(set(self.image_files))
number_of_images = len(self.image_feature_files)
for image_arg, image_file in enumerate(self.image_feature_files):
image_path = image_directory + image_file
if image_arg % 100 == 0:
print('%.2f %% completed' %
round(100 * image_arg / number_of_images, 2))
img = image.load_img(image_path, target_size=(224, 224))
img = image.img_to_array(img)
img = np.expand_dims(img, axis=0)
img = preprocess_input(img)
CNN_features = model.predict(img)
self.extracted_features.append(np.squeeze(CNN_features))
self.extracted_features = np.asarray(self.extracted_features)
elif self.cnn_extractor == 'inceptionresnetv2':
from keras.applications.inception_resnet_v2 import InceptionResNetV2, preprocess_input
base_model = InceptionResNetV2(weights="imagenet")
model = Model(inputs=base_model.input,
outputs=base_model.get_layer('avg_pool').output)
self.extracted_features = []
self.image_feature_files = list(set(self.image_files))
number_of_images = len(self.image_feature_files)
for image_arg, image_file in enumerate(self.image_feature_files):
image_path = image_directory + image_file
if image_arg % 100 == 0:
print('%.2f %% completed' %
round(100 * image_arg / number_of_images, 2))
img = image.load_img(image_path, target_size=(229, 229))
img = image.img_to_array(img)
img = np.expand_dims(img, axis=0)
img = preprocess_input(img)
CNN_features = model.predict(img)
self.extracted_features.append(np.squeeze(CNN_features))
self.extracted_features = np.asarray(self.extracted_features)
elif self.cnn_extractor == 'resnet50':
from keras.applications.resnet50 import ResNet50, preprocess_input
base_model = ResNet50(weights="imagenet")
model = Model(inputs=base_model.input,
outputs=base_model.get_layer('avg_pool').output)
self.extracted_features = []
self.image_feature_files = list(set(self.image_files))
number_of_images = len(self.image_feature_files)
for image_arg, image_file in tqdm(
enumerate(self.image_feature_files)):
image_path = image_directory + image_file
# if image_arg%100 == 0:
# print('%.2f %% completed' %
# round(100*image_arg/number_of_images,2))
img = image.load_img(image_path, target_size=(224, 224))
img = image.img_to_array(img)
img = np.expand_dims(img, axis=0)
img = preprocess_input(img)
CNN_features = model.predict(img)
self.extracted_features.append(np.squeeze(CNN_features))
self.extracted_features = np.asarray(self.extracted_features)
elif self.cnn_extractor == 'xception':
from keras.applications.xception import Xception, preprocess_input
base_model = Xception(weights="imagenet")
model = Model(inputs=base_model.input,
outputs=base_model.get_layer('avg_pool').output)
self.extracted_features = []
self.image_feature_files = list(set(self.image_files))
number_of_images = len(self.image_feature_files)
for image_arg, image_file in enumerate(self.image_feature_files):
image_path = image_directory + image_file
if image_arg % 100 == 0:
print('%.2f %% completed' %
round(100 * image_arg / number_of_images, 2))
img = image.load_img(image_path, target_size=(224, 224))
img = image.img_to_array(img)
img = np.expand_dims(img, axis=0)
img = preprocess_input(img)
CNN_features = model.predict(img)
self.extracted_features.append(np.squeeze(CNN_features))
self.extracted_features = np.asarray(self.extracted_features)
elif self.cnn_extractor == 'resnet152':
from resnet152 import resnet152_model
base_model = resnet152_model("resnet152_weights_tf.h5")
model = Model(inputs=base_model.input,
outputs=base_model.get_layer('avg_pool').output)
self.extracted_features = []
self.image_feature_files = list(set(self.image_files))
number_of_images = len(self.image_feature_files)
for image_arg, image_file in enumerate(self.image_feature_files):
image_path = image_directory + image_file
if image_arg % 100 == 0:
print('%.2f %% completed' %
round(100 * image_arg / number_of_images, 2))
# img = image.load_img(image_path, target_size=(224, 224))
# img = image.img_to_array(img)
img = cv2.resize(cv2.imread(image_path),
(224, 224)).astype(np.float32)
# Remove train image mean
img[:, :, 0] -= 103.939
img[:, :, 1] -= 116.779
img[:, :, 2] -= 123.68
img = np.expand_dims(img, axis=0)
# img = preprocess_input(img)
CNN_features = model.predict(img)
self.extracted_features.append(np.squeeze(CNN_features))
self.extracted_features = np.asarray(self.extracted_features)
def get_model():
base_model = Xception(weights='imagenet', include_top=True)
model = Model(inputs=base_model.input,
outputs=base_model.get_layer('avg_pool').output)
return model
inputs = Input(shape=(224, 224, 3))
x = Lambda(lambda image: ktf.image.resize_images(image, (224, 224)))(inputs)
x = Lambda(lambda image: preprocess_input(image))(x)
# Spatial Path (conv_bn_act with strides = 2 )
SP = conv_bn_act(inputs, 32, strides=2)
SP = conv_bn_act(SP, 64, strides=2)
SP = conv_bn_act(SP, 156, strides=2)
# Context_path (Xception backbone and Attetion Refinement Module(ARM))
Xception_model = Xception(weights='imagenet',
input_shape=(224, 224, 3),
include_top=False)
# 16x Down
layer_13 = Xception_model.get_layer('block13_pool').output
# 32x Down
layer_14 = Xception_model.output
# Context path & ARM
CP_ARM = CP_ARM(layer_13, layer_14)
# Feature Fusion Module(FFM)
FFM = FFM(SP, CP_ARM, 32)
# Upsampling the ouput to normal size
output = UpSampling2D(size=(16, 16),
data_format='channels_last',
interpolation='nearest')(FFM)
bisnet = Model(inputs=[inputs, Xception_model.input],
output=[output, layer_13, layer_14])
history_df[['acc', 'val_acc']].plot()
print("Preds after loading weights")
model.load_weights(modelweights)
preds = model.predict(X_test, verbose=2)
from sklearn.metrics import accuracy_score,f1_score,roc_curve,auc
print(accuracy_score(Y_test,np.round(preds)))
print(f1_score(Y_test,np.round(preds)))
fpr, tpr, thresholds = roc_curve(Y_test, preds)
print("AUC: " + str(auc(fpr, tpr)))
from keras.models import Model
layer_name = 'global_average_pooling2d_1'#'global_average_pooling2d_1'
model_extracted= Model(inputs=model.input, outputs=model.get_layer(layer_name).output)
model_extracted.summary()
Train_Features=model_extracted.predict(X_train)
Train_Target=Y_train
Val_Features=model_extracted.predict(X_val)
Val_Target=Y_val
Test_Features=model_extracted.predict(X_test)
Test_Target=Y_test
import pickle
with open(filetosaveto, "wb") as f:
pickle.dump((Train_Features,Train_Target,Val_Features,Val_Target,Test_Features,Test_Target,model,model_extracted), f)
