def create_xception_model(self):
#vgg16_model = VGG16(include_top=self.vgg16_include_top, weights='imagenet')#包含最上层的连接层，imagenet表示加载imagenet与训练的网络权重.
xception_model=Xception(include_top=True, weights='imagenet', input_tensor=None)
xception_model.compile(optimizer=SGD(), loss='categorical_crossentropy', metrics=['accuracy'])
xception_model.summary()
plot_model(xception_model, to_file='xception_model.png', show_shapes=True)
return xception_model
def extract_features(directory):
dir1=directory
#extracting features
model=Xception()
#removing the last output layer
model.layers.pop()
#defining the Model which will take the input the size of the imahe and output the values in the last layer
model=Model(inputs=model.inputs,output=model.layers[-1].output)
print(model.summary())
features=dict()
file=os.listdir(dir1)
for name in file:
path=os.path.join(dir1,name)
image=load_img(path=path,target_size=(299,299))
#conv to np array
image=img_to_array(image)
image=image.reshape((1,image.shape[0],image.shape[1],image.shape[2]))
#preprocessing the input image according to the Xception model
image=preprocess_input(image)
feature=model.predict(image)
#get the image id
image_id=name.split('.')[0]
features[image_id]=feature
print('>%s'%name)
return features
def create_model(input_shape, config):
input_tensor = Input(shape=input_shape) # this assumes K.image_dim_ordering() == 'tf'
xception_model = Xception(include_top=False, weights=None, input_tensor=input_tensor)
print(xception_model.summary())
x = xception_model.output
x = GlobalAveragePooling2D()(x)
predictions = Dense(config["num_classes"], activation='softmax')(x)
return Model(input=xception_model.input, output=predictions)
def Xception_Yolo(input_shape=(240, 320, 3)):
xception = Xception(weights='imagenet',
include_top=False,
input_shape=input_shape)
xception.summary()
img_input = Input(shape=input_shape)
yolo = xception(img_input)
yolo = Conv2D(128, [1, 1])(yolo)
yolo = BatchNormalization(name='norm_1')(yolo)
yolo = LeakyReLU(alpha=0.1)(yolo)
yolo = Flatten()(yolo)
yolo = Dense(1024)(yolo)
yolo = BatchNormalization()(yolo)
yolo = LeakyReLU(alpha=0.1)(yolo)
yolo = Dense(576)(yolo)
yolo = Reshape((6, 8, 12))(yolo)
model = Model(img_input, yolo)
model.summary()
return model
def load_model(model):
K.clear_session()
if model == "ResNet152":
base_model = ResNet152(include_top=False,
weights='imagenet',
input_shape=(299, 299, 3),
pooling="max")
if model == "InceptionV3":
base_model = InceptionV3(include_top=False,
weights='imagenet',
input_shape=(299, 299, 3),
pooling="max")
if model == "InceptionResNetV2":
base_model = InceptionResNetV2(include_top=False,
weights='imagenet',
input_shape=(299, 299, 3),
pooling="max")
if model == "Xception":
base_model = Xception(include_top=False,
weights='imagenet',
input_shape=(299, 299, 3),
pooling="max")
if model == "VGG":
base_model = VGG19(include_top=False,
weights='imagenet',
input_shape=(299, 299, 3),
pooling="max")
base_model.summary()
x = base_model.output
dense1_ = Dense(512, activation='relu')
dense1 = dense1_(x)
x = Dropout(0.2)(dense1)
dense2 = Dense(256, activation='relu')(x)
x = Dropout(0.2)(dense2)
dense3 = Dense(128, activation='relu')(x)
pred_output = Dense(1, activation='sigmoid')(dense3)
model = Model(inputs=base_model.input, outputs=[pred_output])
model.summary()
return model
def buildModel(self):
# 获取预训练的卷基层
Xinceptionv = Xception(weights='imagenet', include_top=False, pooling="avg")
Xinceptionv.summary()
#plot_model(Xinceptionv, to_file='../data/model.png', show_shapes=True)
# 输入层
input = Input(shape=(self.imgSize, self.imgSize, 3), name = 'image_input')
# 预训练的卷基层
output_Xinceptionv = Xinceptionv(input)
# 加入的全连接层
x = output_Xinceptionv
# x1 = GlobalAveragePooling2D()(x)
# x2 = GlobalMaxPooling2D()(x)
# x = concatenate([x1, x2])
#x = Flatten(name='flatten')(output_resnet50)
#x = Dense(1024, activation="relu", name="fc1")(x)
#x = Dropout(0.5)(x)
#x = Dense(512, activation="relu", name="fc1")(x) # 此处改成avgpool，只用一层，去掉dropout
#x = Dropout(0.5)(x)
x = Dense(100, kernel_regularizer=regularizers.l2(0.01), activation='softmax')(x)
#model_resnet50.trainabel = False # 冻结全部resnet的卷积权重
# for layer in Xinceptionv.layers: # 冻结前面的卷积层
# layer.trainable = False
# 建模
my_model = Model(input=input, output=x)
return my_model
class Model:
def __init__(self, weight_decay=None):
"""
# The range of labels (steeting) in good driving condition goes from -1 to 1. Now this could be a good use
case for tanh.
"""
self.base_model = Xception(
weights='imagenet', input_shape=(90, 320, 3), include_top=False
) # imports the mobilenet model and discards the last 1000
# neuron layer.
if weight_decay is not None:
self.add_weight_decay(weight_decay)
self.crop = Cropping2D(cropping=((50, 20), (0, 0)),
input_shape=(160, 320, 3))
self.normalize = keras.layers.Lambda(lambda x: (x / 255.) - 0.5)
self.flatten = keras.layers.Flatten()
self.dropout = keras.layers.Dropout(0.5)
self.dense_squash = keras.layers.Dense(1, activation="tanh")
def __call__(self):
inputs = keras.layers.Input(shape=(160, 320, 3))
inputs_pp = self.crop(inputs)
inputs_pp = self.normalize(inputs_pp)
inputs_pp = self.base_model(inputs_pp)
inputs_pp = self.flatten(inputs_pp)
# inputs_pp = self.dropout(inputs_pp)
outlayer = self.dense_squash(inputs_pp)
model = keras.Model(inputs=[inputs],
outputs=[outlayer],
name="xception_augmented")
print(self.base_model.summary())
return model
def add_weight_decay(self, decay_val):
for layer in self.base_model.layers:
print("layer: ", layer)
if isinstance(layer, keras.layers.Conv2D) or isinstance(
layer, keras.layers.Dense):
layer.add_loss(lambda: keras.regularizers.l2(decay_val)
(layer.kernel))
if hasattr(layer, 'bias_regularizer') and layer.use_bias:
layer.add_loss(lambda: keras.regularizers.l2(decay_val)
(layer.bias))
def Xception_model():
input_tensor = Input(shape=(dimension, dimension, number_of_channels))
model = Xception(input_tensor=input_tensor,
weights='imagenet',
include_top=True)
model.layers.pop()
model.outputs = [model.layers[-1].output]
model.layers[-1].outbound_nodes = []
x = Dense(number_of_classes, activation='softmax')(model.output)
model = Model(model.input, x)
# the first 24 layers are not trained
for layer in model.layers[:24]:
layer.trainable = False
lrate = 0.001
decay = 0.000001
adam = Adam(lr=lrate, decay=decay)
model.compile(loss='categorical_crossentropy',
optimizer=adam,
metrics=['accuracy'])
print(model.summary())
return model
cam = np.dot(output, weights)
cam = cv2.resize(cam, (299, 299), cv2.INTER_LINEAR)
cam = np.maximum(cam, 0)
cam = cam / cam.max()
jetcam = cv2.applyColorMap(np.uint8(255 * cam), cv2.COLORMAP_JET)
jetcam = cv2.cvtColor(jetcam, cv2.COLOR_BGR2RGB)
jetcam = (np.float32(jetcam) + x / 2)
return jetcam
if __name__ == '__main__':
model = Xception(include_top=False, weights='imagenet', pooling='avg')
model.summary()
all_path = glob.glob('./images/*')
layer_name = [l.name for l in model.layers]
lay = 'global_average_pooling2d_1'
#pprint.pprint(layer_name)
#os.makedirs('./sample', exist_ok=True)
for i, path in enumerate(all_path):
path_result = os.path.join(path, 'grad_result2')
print(path)
os.makedirs(path_result, exist_ok=True)
img_path = glob.glob(path + '/*.png')
for l, img in enumerate(img_path):
x = img_to_array(load_img(img, target_size=(299, 299)))
image = Grad_Cam(model, x, lay)
array_to_img(image)
out_path = os.path.join(path_result, 'output_{0}.png'.format(l))
x = BatchNormalization(name='new_batch_2')(x)
x = Dropout(0.3,name='new_drop_2')(x)
prediction = Dense(3,activation='softmax',name='new_dene_2')(x)
model_1 = Model(inputs=inception_model_1.input,outputs=prediction)
layers = ['new_pool_1','new_batch_1','new_dense_1','new_batch_2','new_drop_2','new_dene_2']
for layer in layers:
lr_dict[layer] = 0.0002*10
!pip install keras-lr-multiplier
from keras_lr_multiplier import LRMultiplier
model_1.summary()
model_1.compile(loss='categorical_crossentropy',optimizer=LRMultiplier('adam', lr_dict),metrics=['accuracy'])
train_set_1 = preprocess_input(preprocess_initial(train_files))
test_set_1 = preprocess_input(preprocess_initial(test_files))
valid_set_1 = preprocess_input(preprocess_initial(valid_files))
layers = ['new_pool_1','new_batch_1','new_dense_1','new_batch_2','new_drop_2','new_dene_2']
model_1.get_layer('new_dene_2').set_weights([np.array(weights[10],dtype=np.float32),np.zeros([3],dtype=np.float32)])
model_1.get_layer('new_dense_1').set_weights([np.array(weights[4],dtype=np.float32),np.zeros([512],dtype=np.float32)])
# the first 249 layers and unfreeze the rest:
for layer in model_1.layers[:249]:
class TestSetAnalysis(object):
"""
class string
"""
def __init__(self, model='vgg19', show=True):
"""
doc string constructor
"""
firstlayer_index = 0
if model=='vgg19':
from keras.applications.vgg19 import VGG19
self.model = VGG19(weights='imagenet', include_top = True)
elif model=='vgg16':
from keras.applications.vgg16 import VGG16
self.model = VGG16(weights='imagenet', include_top = True)
elif model=='inceptionv3':
from keras.applications.inception_v3 import InceptionV3
self.model = InceptionV3(weights='imagenet', include_top = True)
elif model=='resnet50':
from keras.applications.resnet50 import ResNet50
self.model = ResNet50(weights='imagenet', include_top = True)
elif model=='xception':
from keras.applications.xception import Xception
self.model = Xception(weights='imagenet', include_top = True)
elif model.endswith('.hdf5'):
self.model = load_model(model)
firstlayer_index = 1
else:
print("Valid models are:")
print("vgg19, vgg16, inceptionv3, resnet50, xception")
print("xception/inceptionv3 model is only available in tf backend")
print("Or provide path to a saved model in .hdf5 format")
exit()
if show:
print(self.model.summary())
self.inputshape = self.model.layers[firstlayer_index].output_shape[1:]
#------------------------------------------------------------------------------
def predict_gen(self, data_dir, batchsize=32, rescale=1.0/255):
self.data_dir = data_dir
datagen = ImageDataGenerator(rescale=rescale)
self.generator = datagen.flow_from_directory(self.data_dir, \
target_size=self.inputshape[:2], \
batch_size=batchsize, \
class_mode='categorical', \
shuffle=False)
nfiles = []
class_folders = glob(self.data_dir+'*')
for i in range(len(class_folders)):
files = glob(class_folders[i]+'/*')
nfiles.append(len(files))
samples = self.generator.samples
self.nb_class = self.generator.num_class
self.predictions = self.model.predict_generator(self.generator, \
samples/batchsize+1)
self.predictions = self.predictions[:samples, :]
self.predict_labels = np.argmax(self.predictions, axis=1)
self.true_labels = []
for i in range(self.nb_class):
self.true_labels += list([i] * nfiles[i])
self.confusion_matrix = confusion_matrix(\
self.true_labels, \
self.predict_labels)
if self.nb_class==2:
self.FPR, self.TPR, thresholds = roc_curve(\
self.true_labels, \
self.predictions[:,1])
self.roc_auc = roc_auc_score(\
self.true_labels, \
self.predictions[:,1])
self.get_cm_index()
#------------------------------------------------------------------------------
def predict_array(self, xdata, ydata, batchsize=32, rescale=1.0/255):
# samples = self.generator.samples
# self.nb_class = self.generator.num_class
self.predictions = self.model.predict(xdata*rescale, batch_size=batchsize)
# self.predictions = self.predictions[:samples, :]
self.predict_labels = np.argmax(self.predictions, axis=1)
self.true_labels = np.argmax(ydata, axis=1)
self.confusion_matrix = confusion_matrix(\
self.true_labels, \
self.predict_labels)
self.FPR, self.TPR, thresholds = roc_curve(\
self.true_labels, \
self.predictions[:,1])
self.roc_auc = roc_auc_score(\
self.true_labels, \
self.predictions[:,1])
self.get_cm_index()
#------------------------------------------------------------------------------
def get_information_dictionary(self):
mydict = {
"FPR": self.FPR,
"TPR": self.TPR,
"predictions": self.predictions,
"true_labels": self.true_labels,
"predict_labels": self.predict_labels,
"roc_auc": self.roc_auc,
"confusion_matrix": self.confusion_matrix
}
return mydict
#------------------------------------------------------------------------------
def plot_confusion_matrix(self, cmap='Blues', \
save=False, savename='cm.png'):
plt.figure(figsize=(8,8))
matrix = np.zeros(self.confusion_matrix.shape)
for i in range(len(matrix)):
matrix[i] = self.confusion_matrix[i]/\
float(np.sum(self.confusion_matrix[i]))
plt.imshow(matrix, cmap=cmap)
plt.xticks([], [])
plt.yticks([], [])
plt.clim(0, 1)
if save:
print("Now saving confusion matrix figure")
plt.savefig(savename)
else:
plt.show()
return matrix
#------------------------------------------------------------------------------
def plot_roc_curve(self, \
save=False, savename='roc.png'):
plt.figure(figsize=(8,8))
plt.plot(self.FPR, self.TPR, 'k', lw=2)
plt.plot(self.FPR, self.FPR, 'k', lw=0.5)
plt.axhline(y=1, color='k', ls=':', lw=0.5)
plt.axvline(x=0, color='k', ls=':', lw=0.5)
plt.xlim(-0.01,1)
plt.ylim(0,1.01)
plt.xlabel('$\mathtt{FalsePositiveRate}$', fontsize=22)
plt.ylabel('$\mathtt{TruePositiveRate}$', fontsize=22)
if save:
f.savefig(savefigname)
else:
plt.show()
#------------------------------------------------------------------------------
def plot_samples(self, ind_arr, title, N=100, ncol=15, \
save=False, savefigname='samples.eps'):
ind_arr = np.random.choice(ind_arr, size=N, replace=False)
names = np.array(self.generator.filenames)[ind_arr]
N = N - N%ncol
print(N)
nrow = N/ncol
f, axarr = plt.subplots(nrow, ncol, sharex=True, sharey=True, \
figsize=(ncol, nrow))
f.subplots_adjust(wspace=0.0, hspace=0)
f.suptitle("$\mathtt{%s}$"%title, fontsize=22)
for i in range(nrow):
for j in range(ncol):
axarr[i,j].imshow(cv2.imread(self.data_dir+names[i*ncol+j]))
axarr[i,j].set_xticks([], [])
axarr[i,j].set_yticks([], [])
if save:
f.savefig(savefigname)
else:
plt.show()
#------------------------------------------------------------------------------
def get_cm_index(self):
self.tp = []
self.tn = []
self.fp = []
self.fn = []
for i in range(len(self.true_labels)):
if self.true_labels[i]==1 and self.predict_labels[i]==1:
self.tp.append(i)
elif self.true_labels[i]==0 and self.predict_labels[i]==0:
self.tn.append(i)
elif self.true_labels[i]==0 and self.predict_labels[i]==1:
self.fp.append(i)
elif self.true_labels[i]==1 and self.predict_labels[i]==0:
self.fn.append(i)
#------------------------------------------------------------------------------
def plot_all(self):
self.plot_confusion_matrix()
if self.nb_class==2:
self.plot_roc_curve()
self.plot_samples(self.tp, 'TruePositive')
self.plot_samples(self.fp, 'FalsePositive')
self.plot_samples(self.tn, 'TrueNegative')
self.plot_samples(self.fn, 'FalseNegative')
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()
# from keras.applications.resnet50 import ResNet50
from keras.applications.xception import Xception
from keras.preprocessing import image
from keras.applications.xception import preprocess_input, decode_predictions
from keras.utils.vis_utils import plot_model
import numpy as np
# import matplotlib.pyplot as plt
# model = ResNet50(weights='imagenet')
model = Xception()
print(model.summary())
# plot_model(model, to_file='xception.png')
model = Xception(weights='imagenet')
img_path = 'elephant.jpg'
# img_path = 'parrot.jpg'
img = image.load_img(img_path, target_size=(299, 299))
x = image.img_to_array(img)
# plt.imshow(x / 255.)
# plt.show()
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
preds = model.predict(x)
# decode the results into a list of tuples (class, description, probability)
# (one such list for each sample in the batch)
print('Predicted:', decode_predictions(preds, top=8)[0])
# img.show()
for pred in decode_predictions(preds, top=8)[0]:
print(pred)
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'
trainpath = 'trainval_' + superclass + '/train'
valpath = 'trainval_' + superclass + '/val'
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+'_crop'\
+'/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 = ImageDataGenerator(rescale=1. / 255,
rotation_range=15,
width_shift_range=5,
height_shift_range=5,
horizontal_flip=True)
test_datagen = ImageDataGenerator(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 MobileNet
model = Xception(include_top=True,
weights=None,
input_tensor=None,
input_shape=(72, 72, 3),
pooling=None,
classes=classNum[superclass[0]])
model.summary()
model.compile(optimizer=SGD(lr=lr, momentum=0.9),
loss='categorical_crossentropy',
metrics=['accuracy'])
steps_per_epoch = int(train_generator.n / batchsize)
validation_steps = int(valid_generator.n / batchsize)
weightname = 'model/mobile_' + superclass + '_wgt.h5'
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=100,
validation_data=valid_generator,
validation_steps=validation_steps,
callbacks=[checkpointer])
# In[ ]:
from keras.applications.xception import Xception
xception_weights_path = "xception_weights_tf_dim_ordering_tf_kernels_notop.h5"
xception_conv_base = Xception(include_top=False,
weights=None,
input_tensor=None,
input_shape=(224, 224, 3),
pooling=None,
classes=None)
xception_conv_base.load_weights(xception_weights_path)
#xception_conv_final_predictor = Xception(include_top=False, weights="imagenet", input_tensor=None, input_shape=(224, 224, 3), pooling=None, classes=None)
xception_conv_base.summary()
#xception_conv_base.load_weights(xception_weights_path)
# In[ ]:
xception_conv_base.weights
# In[ ]:
from keras.models import Sequential, Model
from keras.layers import Flatten, Dense, Lambda, Input, Multiply, Dot, Add, Concatenate, Average
from keras import backend as K
import tensorflow as tf
input_shape=(img_h, img_w, 3),
pooling=None,
classes=num_classes)
#x = Flatten()(base_model.output)
#predictions = Dense(num_classes, activation = 'softmax')(x)
#create graph of your new model
#model = Model(input = base_model.input, output = predictions)
#model = multi_gpu_model(model, gpus=2)
model.compile(loss='categorical_crossentropy',
optimizer='Adam',
metrics=['accuracy'])
print model.summary()
model_name = os.path.join(args.model_dir,
"doc_detect.{epoch:02d}-{val_loss:.2f}.hdf5")
checkpointer = ModelCheckpoint(model_name,
monitor='val_acc',
verbose=1,
save_best_only=True,
save_weights_only=False,
mode='auto',
period=1)
train_datagen = ImageDataGenerator(rescale=1. / 255)
test_datagen = ImageDataGenerator(rescale=1. / 255)
plt.plot(history5.history['loss'])
plt.plot(history5.history['val_loss'])
plt.title('Resnet152V2 model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper right')
plt.savefig('resnet152_loss')
plt.show()
"""## Xception Net"""
from keras.applications.xception import Xception
xcept = Xception(include_top=False, weights='imagenet')
xcept.summary()
x = xcept.output
x = GlobalAveragePooling2D()(x)
x = Dense(512, activation='relu')(x)
x = Dropout(0.3)(x)
predictions = Dense(4, activation='softmax')(x)
model = Model(inputs=xcept.input, outputs=predictions)
for layer in xcept.layers:
layer.trainable = False
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy',f1_m,precision_m, recall_m])
def main(args):
# hyper parameters
batch_size = 16
num_classes = 102
epochs = 100
# Instantiate model
model = Xception(include_top=True, weights=None, classes=num_classes)
# prepare data
x_train = np.load(os.path.join(current_directory, 'x_train.npy'))
y_train = np.load(os.path.join(current_directory, 'y_train.npy'))
x_test = np.load(os.path.join(current_directory, 'x_test.npy'))
y_test = np.load(os.path.join(current_directory, 'y_test.npy'))
# summary of the model
model.summary()
# compile model
model.compile(
loss=categorical_crossentropy,
optimizer=Adadelta(),
metrics=['accuracy']
)
# learning section
hist = model.fit(
x_train,
y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(x_test, y_test)
)
# evaluation section
score = model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
# save graphs
acc = hist.history['acc']
val_acc = hist.history['val_acc']
loss = hist.history['loss']
val_loss = hist.history['val_loss']
plt.plot(range(epochs), loss, marker='.', label='acc')
plt.plot(range(epochs), val_loss, marker='.', label='val_acc')
plt.legend(loc='best')
plt.grid()
plt.xlabel('epoch')
plt.ylabel('acc')
plt.savefig(os.path.join(current_directory, 'acc_xception.png'))
plt.clf()
plt.plot(range(epochs), acc, marker='.', label='loss')
plt.plot(range(epochs), val_acc, marker='.', label='val_loss')
plt.legend(loc='best')
plt.grid()
plt.xlabel('epoch')
plt.ylabel('loss')
plt.savefig(os.path.join(current_directory, 'loss_xception.png'))
plt.clf()
pre_model = VGG19(weights='imagenet', include_top=False)
detect_dog_model = VGG19(weights='imagenet')
elif settings.PRETRAINED_MODEL == 'InceptionV3':
from keras.applications.inception_v3 import InceptionV3, preprocess_input
pre_model = InceptionV3(weights='imagenet', include_top=False)
detect_dog_model = InceptionV3(weights='imagenet')
elif settings.PRETRAINED_MODEL == 'Resnet50':
from keras.applications.resnet50 import ResNet50, preprocess_input
pre_model = ResNet50(weights='imagenet', include_top=False)
detect_dog_model = ResNet50(weights='imagenet')
elif settings.PRETRAINED_MODEL == 'Xception':
from keras.applications.xception import Xception, preprocess_input
pre_model = Xception(weights='imagenet', include_top=False)
detect_dog_model = Xception(weights='imagenet')
pre_model.summary()
model = load_model(settings.MODEL_TOP_LAYER)
model.summary()
graph = tf.get_default_graph()
def predict_img(img_path):
with graph.as_default():
tensor = path_to_tensor(img_path)
pre_processed_img = preprocess_input(tensor)
bottleneck_feature = pre_model.predict(tensor)
predicted_vector = model.predict(bottleneck_feature)
return settings.DOG_NAMES[np.argmax(predicted_vector)]
testTulipssDir = os.path.join(testDir, 'Tulips')
print("Testing Folders Completed")
print("")
#######################################################
#######################################################
print("") #build NN
#######################################################
#######################################################
print("Building Neural Network")
convBase = Xception(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000)
convBase.summary()
print("Completed Importing InceptionV3")
print("Scale Images Generator")
dataGen = ImageDataGenerator(rescale=1. / 255)
batchSize = 20
print("Completed Scale Images Generator")
def extractFeatures(directory, sampleCount):
features = np.zeros(shape=(sampleCount, 4, 4, 512))
labels = np.zeros(shape=(sampleCount))
generator = dataGen.flow_from_directory(directory,
target_size=(150, 150),
batch_size=batchSize,
class_mode='binary')
# Load the dataset
test_dir = "test/"
# data generator sem o augmentation - para a validação
datagen_no_aug = ImageDataGenerator(rescale=1. / 255)
# Create the model
input_img = Input(shape=(299, 299, 3))
# pre-trained model
pt_model = Xception(include_top=False,
weights='imagenet',
input_tensor=input_img,
input_shape=(299, 299, 3),
pooling='avg')
print pt_model.summary()
for layer in pt_model.layers[:-15]:
layer.trainable = False
for layer in pt_model.layers[-15:]:
layer.trainable = True
# new fully connected layer
x = pt_model.layers[-1].output
"""
conv1 = Conv2D(32, kernel_size=(3,3), padding='valid')(x)
conv1 = BatchNormalization()(conv1)
conv1 = Activation('relu')(conv1)
conv1 = Conv2D(32, kernel_size=(3,3), padding='valid')(conv1)
conv1 = BatchNormalization()(conv1)
sortd.tail()
# In[ ]:
#Class weighting
cw = np.median(sortd.values) / sortd.values
print(cw)
# In[ ]:
from keras.applications.xception import Xception
premodel = Xception(include_top=False,
weights='imagenet',
input_shape=(299, 299, 3),
classes=num_classes)
premodel.summary()
# In[ ]:
# for layer in premodel.layers[:5]:
# layer.trainable = False
# In[ ]:
from keras.layers.pooling import GlobalAveragePooling2D
from keras.layers import Dense
#Adding custom Layers
# x = model.output
# x = Flatten()(x)
# x = Dense(1024, activation="relu")(x)
if IMG_SIZE !=224:
model = MobileNetV2(weights='imagenet',include_top=False,input_shape=(224, 224,3))
new_model = change_model(model,new_input_shape=(None, IMG_SIZE, IMG_SIZE, 3))
else:
new_model = MobileNetV2(weights='imagenet',include_top=False,input_shape=(224, 224,3))
elif themodel =='ResNet50':
from keras.applications import ResNet50
if IMG_SIZE !=224:
model = ResNet50(weights='imagenet',include_top=False,input_shape=(224, 224,3))
new_model = change_model(model,new_input_shape=(None, IMG_SIZE, IMG_SIZE, 3))
else:
new_model = ResNet50(weights='imagenet',include_top=False,input_shape=(224, 224,3))
new_model.summary()
# In[26]:
def build_model():
model = Sequential()
model.add(new_model)
model.add(layers.GlobalAveragePooling2D())
model.add(layers.Dropout(0.5))
model.add(layers.Dense(13, activation='sigmoid'))
model.add(layers.Dense(1, activation='sigmoid'))
model.compile(
loss='binary_crossentropy',
print('1')
import os
from pathlib import Path
from os import listdir
import pandas as pd
import numpy as np
import sklearn.model_selection as m
import tensorflow as tf
from keras.preprocessing.image import load_img
from keras.preprocessing.image import img_to_array
from keras.applications.xception import preprocess_input,Xception
from keras.models import Model
#%%
x=Xception()
x.summary()
#%%
def extract_features(directory):
dir1=directory
#extracting features
model=Xception()
#removing the last output layer
model.layers.pop()
#defining the Model which will take the input the size of the imahe and output the values in the last layer
model=Model(inputs=model.inputs,output=model.layers[-1].output)
print(model.summary())
features=dict()
file=os.listdir(dir1)
for name in file:
path=os.path.join(dir1,name)
x = layers.MaxPool2D(pool_size=(3, 3), strides=2, padding='same')(x)
x = layers.add([x, res])
# layer 20 #
x = SeparableConv2D(filters=1536,
kernel_size=(3, 3),
strides=1,
padding='same',
use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
# layer 21 #
x = SeparableConv2D(filters=2048,
kernel_size=(3, 3),
strides=1,
padding='same',
use_bias=False)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = layers.GlobalAveragePooling2D()(x)
output = layers.Dense(units=1000, activation='softmax')(x)
xception = models.Model(input_layer, output)
xception.summary()
### examples ###
xc = Xception(input_shape=(299, 299, 3))
xc.summary()
fit_epochs = 50
batch_size = 24
nb_classes = 5
nb_epoch = 10
#build CNN
model_Xception_conv = Xception(weights='imagenet', include_top=False)
input = Input(shape=(img_width, img_height, 3),name = 'image_input')
output_vgg16_conv = model_Xception_conv(input)
for layer in model_Xception_conv.layers[:15]:
layer.trainable = False
model_Xception_conv.summary()
x = Flatten(name='flatten')(output_vgg16_conv)
x = Dense(256, activation='relu')(x)
x = Dropout(0.5)(x)
x = Dense(5, activation='softmax', name='predictis')(x)
xception_model = Model(inputs=input, outputs=x)
xception_model.summary()
#Image preprocessing and image augmentation with keras
xception_model.compile(loss='categorical_crossentropy',
optimizer=optimizers.SGD(lr=1e-3, momentum=0.9),
metrics=['accuracy']
elif args.model == "NASNetLarge":
from keras.applications.nasnet import preprocess_input
from keras.applications.nasnet import decode_predictions
preprocessing_function = preprocess_input
base_model = NASNetLarge()
image = load_img('soccer_ball.jpeg', target_size=(224, 224))
elif args.model == "NASNetMobile":
from keras.applications.nasnet import preprocess_input
from keras.applications.nasnet import decode_predictions
preprocessing_function = preprocess_input
base_model = NASNetMobile()
image = load_img('soccer_ball.jpeg', target_size=(224, 224))
else:
ValueError("The model you requested is not supported in Keras")
base_model.summary()
# convert the image pixels to a numpy array
image = img_to_array(image)
# reshape data for the model
image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2]))
# prepare the image for the VGG model
image = preprocess_input(image)
# predict the probability across all output classes
yhat = base_model.predict(image)
# convert the probabilities to class labels
label = decode_predictions(yhat)
# retrieve the most likely result, e.g. highest probability
label = label[0][0]
# print the classification
print('%s (%.2f%%)' % (label[1], label[2] * 100))
if __name__ == "__main__":
train_dir = 'data/train'
valid_dir = 'data/valid'
test_dir = 'data/test'
# load file paths
train_paths = glob.glob(os.path.join(train_dir, '*', '*.jpg'))
valid_paths = glob.glob(os.path.join(valid_dir, '*', '*.jpg'))
test_paths = glob.glob(os.path.join(test_dir, 'unknown', '*.jpg'))
random.shuffle(train_paths)
# load pretrained model
xception_bottleneck = Xception(weights='imagenet', include_top=False, pooling='avg')
xception_bottleneck.summary()
# extract Xception bottleneck features
if not os.path.exists('train_feats_xception.npy'):
train_feats = extract_features(xception_bottleneck, train_paths)
valid_feats = extract_features(xception_bottleneck, valid_paths)
test_feats = extract_features(xception_bottleneck, test_paths)
# save features
np.save('train_feats_xception.npy', train_feats)
np.save('valid_feats_xception.npy', valid_feats)
np.save('test_feats_xception.npy', test_feats)
else:
train_feats = np.load('train_feats_xception.npy')
valid_feats = np.load('valid_feats_xception.npy')
test_feats = np.load('test_feats_xception.npy')
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
class FaceEmotion:
"""Class for recognizing emotion using default Deep Learning Xception model"""
def __init__(self, input_shape=(200, 200, 3)): # TODO: Check input_shape
"""Initialize main parameters of FaceEmotion class
:param input_shape: Input images shape
"""
self.input_shape = input_shape
self.model = Xception(include_top=False, input_shape=input_shape)
self.model = self.add_classificator(self.model)
@staticmethod
def add_classificator(base_model):
"""Add a classificator to a model
:param base_model: Keras model object
"""
layer = base_model.output
layer = GlobalAveragePooling2D(name="classificator_block_pool")(layer)
layer = Dense(512,
activation='relu',
name='classificator_block_dense_1')(layer)
layer = Dense(64,
activation='relu',
name='classificator_block_dense_2')(layer)
layer = Dense(6, activation='relu',
name='classificator_block_dense_3')(layer)
model = Model(inputs=base_model.input, outputs=layer)
# freeze early layers
for l in base_model.layers:
l.trainable = False
model.compile(optimizer='sgd',
loss='mean_squared_error',
metrics=['accuracy'])
return model
def model_architecture(self, filename=None):
"""Show model architecture and save it to file
:param filename: Path to the model architecture image file
"""
list_summary = []
self.model.summary(print_fn=lambda x: list_summary.append(x))
summary = "\n".join(list_summary)
if filename:
with open(filename + '.txt', 'w') as f:
f.write(summary)
from keras.utils import plot_model
plot_model(self.model, filename + '.jpg')
return summary
# noinspection PyShadowingNames
def train(self, generator, epochs, steps_per_epoch):
"""Train model
:param generator: Data generator compatible with Keras model
:param epochs: Number of epochs to train model
:param steps_per_epoch: Number of faces used in one step
"""
stopper = EarlyStopping(patience=100) # , restore_best_weights=True)
save_dir = "training/e{epoch:02d}-a{acc:.2f}.ckpt"
saver = ModelCheckpoint(save_dir) # , save_best_only=True)
self.model.fit_generator(generator,
steps_per_epoch,
epochs,
callbacks=[stopper, saver])
def get_emotion(self, image):
emotions = []
for top, right, bottom, left in face_locations(image):
emotion = self.model.predict(image[top:bottom, left:right])
emotions.append(emotion)
return emotions
