## https://github.com/soeaver/caffe-model/blob/master/cls/evaluation_cls.py
# https://github.com/soeaver/caffe-model/blob/master/cls/synset.txt
# (441) 810 n02823750 beer glass
# ( 1) 449 n01443537 goldfish, Carassius auratus
# ( 9) 384 n01518878 ostrich, Struthio camelus
img_file = '/root/share/data/imagenet/dummy/256x256/goldfish.jpg'
img_file = '/root/share/data/imagenet/dummy/256x256/beer_glass.jpg'
img_file = '/root/share/data/imagenet/dummy/256x256/ostrich.jpg'
img = image.load_img(img_file, target_size=(299, 299))
#img = np.ones((299,299,3),np.uint8)
keras_model = KXception(include_top=True, weights='imagenet', input_tensor=None)
xx = image.img_to_array(img)
xx = np.expand_dims(xx, axis=0)
xx = preprocess_input(xx)
preds = keras_model.predict(xx)
# 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=3)[0])
## dump keras weights ###############################################
keras_weights = dict()
for layer in keras_model.layers: # dump all weights (trainable and not) to dict {layer_name: layer_weights}
for layer, layer_weights in zip(layer.weights, layer.get_weights()):
keras_weights[layer.name] = layer_weights
def train(epochs):
image_size = (299, 299)
# variables to hold features and labels
features = []
labels = []
# default setting in keras models
class_count = 1000
X_test = []
name_test = []
trainData = np.loadtxt("./train.txt", dtype="str", delimiter=' ')
for k in range(len(trainData)):
aLine = trainData[k]
image_path = aLine[0]
label = int(aLine[1])
ground_truth = np.zeros(class_count, dtype=np.float32)
ground_truth[label] = 1
img = image.load_img(image_path, target_size=image_size)
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
labels.append(ground_truth)
features.append(x[0])
trainData = np.loadtxt("./val.txt", dtype="str", delimiter=' ')
for k in range(len(trainData)):
aLine = trainData[k]
image_path = aLine[0]
label = int(aLine[1])
ground_truth = np.zeros(class_count, dtype=np.float32)
ground_truth[label] = 1
img = image.load_img(image_path, target_size=image_size)
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
labels.append(ground_truth)
features.append(x[0])
testData = np.loadtxt("./test.txt", dtype="str", delimiter=' ')
for k in range(len(testData)):
aLine = testData[k]
image_path = aLine
img = image.load_img(image_path, target_size=image_size)
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
X_test.append(x[0])
name_test.append(image_path)
X_train = features
y_train = labels
X_train = np.array(X_train)
Y_train = np.array(y_train)
# test image
X_test = np.array(X_test)
# Use Xception
model = Xception(include_top=True, weights='imagenet', classes=class_count)
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(X_train, Y_train, epochs=epochs, verbose=1, validation_split=0.3)
Y_pred = model.predict(X_test)
f = open('project2_08573584.txt', 'w')
for i in range(len(name_test)):
predict = Y_pred[i].argmax(axis=0)
f.write(str(predict) + '\n')
f.close()
class Xception:
def __init__(self):
self.input_shape = (299, 299, 3)
self.weight = 'imagenet'
self.pooling = 'avg'
self.load_config()
def load_config(self):
# read model config from environment
self.device_str = os.environ.get("device_id", "/cpu:0")
self.user_config = tf.ConfigProto(allow_soft_placement=False)
gpu_mem_limit = float(os.environ.get("gpu_mem_limit", 0.3))
self.user_config.gpu_options.per_process_gpu_memory_fraction = gpu_mem_limit
self.user_config.gpu_options.allow_growth = True
if os.environ.get("log_device_placement", False):
self.user_config.log_device_placement = True
print("device id %s, gpu memory limit: %f" %
(self.device_str, gpu_mem_limit))
self.graph = tf.Graph()
with self.graph.as_default():
with tf.device(self.device_str):
self.session = tf.Session(config=self.user_config)
KTF.set_session(self.session)
self.model = KerasXception(weights=self.weight,
input_shape=(self.input_shape[0],
self.input_shape[1],
self.input_shape[2]),
pooling=self.pooling,
include_top=False)
self.graph = KTF.get_graph()
self.session = KTF.get_session()
self.model.trainable = False
self.model.predict(
np.zeros((1, self.input_shape[0], self.input_shape[1], 3)))
def extract_feature(self, img_path):
img = image.load_img(img_path,
target_size=(self.input_shape[0],
self.input_shape[1]))
img = image.img_to_array(img)
img = np.expand_dims(img, axis=0)
img = preprocess_input_xception(img)
with self.graph.as_default():
with tf.device(self.device_str):
with self.session.as_default():
feat = self.model.predict(img)
norm_feat = feat[0] / LA.norm(feat[0])
norm_feat = [i.item() for i in norm_feat]
return norm_feat
@property
def name(self):
return "xception"
@property
def type(self):
return "encoder"
@property
def input(self):
return "image"
@property
def output(self):
return "vector"
@property
def dimension(self):
return "2048"
@property
def metric_type(self):
return "L2"
metrics=['acc'])
with open('Finetuned_DXception_finale_7.json', 'w') as f: # save the model
f.write(cas_classifier.to_json())
checkpointer = ModelCheckpoint(
filepath='Finetuned_DXception_finale_7.hdf5',
verbose=1,
save_best_only=False,
mode='min'
) #saves the model weights after each epoch if the validation loss decreased
(val_noisy, val_labels) = validation_data_generation(Val_list, Val_size)
val_labels = to_categorical(val_labels, num_classes=1000)
NPredicted_Labels = np.argmax(classifier.predict(val_noisy), 1)
Noisy_accuracy = np.mean(
np.equal(NPredicted_Labels, np.argmax(val_labels, axis=1)))
print('Noisy accuracy on Xception before fine-tunning:' + str(Noisy_accuracy))
#val_denoised=De_model.predict(val_noisy, verbose=1,batch_size=batch_size)
NPredicted_Labels = np.argmax(cas_classifier.predict(val_noisy), 1)
Noisy_accuracy = np.mean(
np.equal(NPredicted_Labels, np.argmax(val_labels, axis=1)))
print('Noisy accuracy on cascaded_Xception before fine-tunning:' +
str(Noisy_accuracy))
for i in range(5):
print('%.i-th Training data loading...' % (i + 1))
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')
class image_analysis(object):
"""
class string
"""
def __init__(self, model='vgg19'):
"""
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()
self.inputshape = self.model.layers[firstlayer_index].output_shape[1:]
#------------------------------------------------------------------------------
def get_labels(self, path):
"""
my doc string
"""
labels = []
f = open(path, 'r')
while True:
line = f.readline()
if not line:
break
labels.append(line)
f.close()
return labels
#------------------------------------------------------------------------------
def get_image_input(self, imagepath):
"""
my doc string
"""
shape = self.inputshape[:2]
im = cv2.resize(cv2.imread(imagepath), shape).astype(np.float32)
im[:,:,0] -= 103.939
im[:,:,1] -= 116.779
im[:,:,2] -= 123.68
im = np.expand_dims(im, axis=0)
return im
#------------------------------------------------------------------------------
def get_image_category(self, imagepath=None, labelpath=None, k=5):
if imagepath==None or labelpath==None:
print("Usage: predict_image(imagepage, labelpath)")
exit()
im = self.get_image_input(imagepath)
out = self.model.predict(im)
idxs = np.argsort(out[0])[::-1][:k]
labels = self.get_labels(labelpath)
results = np.array(labels, dtype='str')[idxs]
probs = np.array(out[0,idxs], dtype='float')
dictionary = {}
for i in range(k):
dictionary[results[i].replace('\n','')] = probs[i]
return dictionary
#------------------------------------------------------------------------------
def get_features(self, img_path, layername='fc1'):
model = Model(inputs=self.model.input, \
outputs=self.model.get_layer(layername).output)
im = self.get_image_input(img_path)
features = model.predict(im)
return features
#------------------------------------------------------------------------------
def get_features_vector(self, img_path, layername='fc1'):
features = self.get_features(img_path, layername)
return np.ndarray.flatten(features)
#------------------------------------------------------------------------------
def get_layernames(self):
allnames = []
for i in range(len(self.model.layers)):
names = self.model.layers[i].name
allnames.append(names)
return allnames
#------------------------------------------------------------------------------
def plot_conv_features(self, image, layer=None, \
save=False, savefilename='features.eps'):
if layer==None:
names = self.get_layernames()
for i in range(len(names)):
if 'conv' in names[i]:
layer=names[i]
break
elif type(layer)==int:
names = self.get_layernames()
layer = names[layer]
if not (('conv' in layer) or ('pool' in layer)):
print("please provide name or index of convolution/pooling layer")
exit()
features = self.get_features(image, layer)
N = features.shape[-1]
nrow = int(N**0.5)
ncol = int(N**0.5)
print("=================================================")
print("Layer name: ", layer)
print("Features shape: ", features.shape)
print("Number of rows and columns: ", nrow, ncol)
print("=================================================")
f, axarr = plt.subplots(nrow, ncol, \
sharex=True, sharey=True, figsize=(20,20))
# f.suptitle('$\mathtt{%s}$'%layer.replace('_', " "), fontsize=22)
f.subplots_adjust(wspace=0.02, hspace=0.02)
for i in range(nrow):
for j in range(ncol):
axarr[i,j].imshow(features[0,:,:,i*ncol+j], cmap='jet')
axarr[i,j].set_xticks([], [])
axarr[i,j].set_yticks([], [])
if save:
f.savefig(savefilename)
else:
plt.show()
#------------------------------------------------------------------------------
def plot_all_conv_features(self, image, DIR='figures/'):
if not os.path.exists(DIR):
os.mkdir(DIR)
names = self.get_layernames()
for i in range(len(names)):
if ('conv' in names[i]) or ('pool' in names[i]):
filename = DIR+names[i]+'.eps'
self.plot_conv_features(image, names[i],save=True, savefilename=filename)
# Load our model
# model = densenet169_model(img_rows=img_rows, img_cols=img_cols, color_type=channel, num_classes=num_classes)
# load keras model
model = Xception(weights=None, classes=10)
sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(optimizer=sgd,
loss='categorical_crossentropy',
metrics=['accuracy'])
model.summary()
# Start Fine-tuning
model.fit(
X_train,
Y_train,
batch_size=batch_size,
epochs=nb_epoch,
shuffle=True,
verbose=1,
validation_data=(X_valid, Y_valid),
)
# Make predictions
predictions_valid = model.predict(X_valid,
batch_size=batch_size,
verbose=1)
# Cross-entropy loss score
score = log_loss(Y_valid, predictions_valid)
# In[ ]:
from keras.models import load_model
#model = load_model('/content/drive/My Drive/ColabNotebooks/AllmodeloRMSpropXception.h5')
model = load_model(
'/content/drive/My Drive/ColabNotebooks/Xception/modelXception.h5')
# ## Predict the Model Trained
# **Show the three better images and the three wrong image of the test set**
# In[ ]:
predictTest = model.predict(x_test, verbose=1)
predictTest = predictTest.reshape(predictTest.shape[0])
#predictTest = predictTest.astype('int32')
#print(x_test.shape)
#print(predictTest.shape)
#print(y_test.shape)
#print(np.round(predictTest))
#print(y_test)
#print(predictTest)
mae = np.abs(y_test - predictTest)
#print(mae)
pos = np.argsort(mae)
print(pos[-1])
print(pos[-2])
from keras.applications.xception import Xception
from keras.preprocessing import image
from keras.applications.xception import preprocess_input, decode_predictions
from PIL import Image
import numpy as np
import os
import time
model = Xception(weights='imagenet')
images = os.listdir('resources')
times = []
for img_path in images:
img = image.load_img('resources/' + img_path, target_size=(299, 299))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
start_time = time.time()
preds = model.predict(x)
times.append(time.time() - start_time)
# decode the results into a list of tuples (class, description, probability)
# (one such list for each sample in the batch)
print('Predicted for ' + img_path + ": ", decode_predictions(preds, top=3)[0])
print("Average prediction time: %s seconds" % np.mean(times))
# load the input image using the Keras helper utility while ensuring
# that the image is resized to 224x224 pxiels, the required input
# dimensions for the network -- then convert the PIL image to a
# NumPy array
print("[INFO] loading and preprocessing image...")
image = image_utils.load_img(args["image"], target_size=(224, 224))
image = image_utils.img_to_array(image)
# our image is now represented by a NumPy array of shape (3, 224, 224),
# but we need to expand the dimensions to be (1, 3, 224, 224) so we can
# pass it through the network -- we'll also preprocess the image by
# subtracting the mean RGB pixel intensity from the ImageNet dataset
image = np.expand_dims(image, axis=0)
image = preprocess_input(image)
# load the VGG16 network
print("[INFO] loading network...")
model = Xception(weights="imagenet")
# classify the image
print("[INFO] classifying image...")
preds = model.predict(image)
label = decode_predictions(preds, top=3)[0]
print('Predicted:', label)
# display the predictions to our screen
cv2.putText(orig, "Label: {}".format(label), (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
cv2.imshow("Classification", orig)
cv2.waitKey(0)
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
plt.subplots(figsize=(10,10)) plt.tight_layout() display_training_curves(history1.history['accuracy'], history1.history['val_accuracy'], 'accuracy', 211) display_training_curves(history1.history['loss'], history1.history['val_loss'], 'loss', 212) n1=224 m1=224 features1 = [] for image in x_train: image = cv2.resize(image , (n1,m1) ) image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2])) image = preprocess_input(image) feature = res.predict(image) features1.append(feature) featurestest1 = [] for image in x_test: image = cv2.resize(image , (n1,m1) ) image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2])) image = preprocess_input(image) feature = res.predict(image) featurestest1.append(feature) features = np.array(features1)
#____________________________________________ GRAD CAM RESNET50______________________________________________
def normalize(x):
# utility function to normalize a tensor by its L2 norm
return x / (K.sqrt(K.mean(K.square(x))) + 1e-5)
model = Xception()
plot_model(model, to_file='model/xception.png')
image = load_img(input_images_dir + '/input.jpg', target_size=(229, 229))
image = img_to_array(image)
image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2]))
image = preprocess_input(image)
predictions = model.predict(image)
predicted_class = np.argmax(predictions)
def target_category_loss(x, category_index, nb_classes):
return tf.multiply(x, K.one_hot([category_index], nb_classes))
def target_category_loss_output_shape(input_shape):
return input_shape
activation_layer = 'block14_sepconv2_act'
nb_classes = model.get_layer('predictions').output.shape[
1] # get number of classes
target_layer = lambda x: target_category_loss(x, predicted_class, nb_classes)
net = Dropout(0.34)(Xception_branch)
net = Dense(1024, use_bias=False, kernel_initializer='uniform')(net)
net = BatchNormalization()(net)
net = Activation("relu")(net)
net = Dropout(0.34)(net)
net = Dense(120, kernel_initializer='uniform', activation="softmax")(net)
model = Model(inputs=[Xception_input], outputs=[net])
model.summary()
model.load_weights('2019-03-18_dog_breed_model.h5')
name_f = np.load('names.npy')
X_validXception = np.zeros((1, 10, 10, 2048), dtype=np.float32)
img = load_img('chien.jpg', target_size=(299, 299)) # this is a PIL image
x_img = img_to_array(img)
x_img = x_img.reshape((1, ) + x_img.shape)
imput_train_xception = preprocess_input_Xception(x_img.copy())
train_xception = model_xception.predict(
imput_train_xception) # ,batch_size=32)
X_validXception[0, :, :, :] = train_xception[0, :, :, :]
predictions = model.predict([X_validXception])
print('voici la race du chien prédite par notre algorithme : {}'.format(
name_f[int(np.argmax(predictions))]))
from keras.preprocessing.image import load_img
from keras.preprocessing.image import img_to_array
from keras.applications.xception import preprocess_input
from keras.applications.xception import decode_predictions
from keras.applications.xception import Xception
model = Xception(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000)
for i in range(0, 5):
print('-----------------------------------------------')
# load an image from file
image = load_img('../resources/wolf_'+str(i+1)+'.jpg', target_size=(224, 224))
# 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 = model.predict(image)
# convert the probabilities to class labels
label = decode_predictions(yhat)
for i in range(0, len(label[0])):
# retrieve the most likely result, e.g. highest probability
labelTemp = label[0][i]
# print the classification
print('%s (%.2f%%)\n' % (labelTemp[1], labelTemp[2]*100))
for i in range(20):
model = Xception(include_top=True,
weights='weights_Xception_ten_res{}.hdf5'.format(i),
input_tensor=None,
input_shape=input_shape,
pooling=None,
classes=10)
Adam(lr=0.005,
beta_1=0.9,
beta_2=0.999,
epsilon=None,
decay=0.0,
amsgrad=False)
model.compile(optimizer='Adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
result_class += model.predict(x_test)
result = np.array(np.argmax(result_class, axis=1),
'int').reshape(x_test.shape[0], 1)
result_id = np.arange(0, x_test.shape[0]).reshape(-1, 1)
resultt = np.concatenate((result_id, result), axis=1)
np.savetxt("xception_ten.csv",
resultt,
fmt='%i',
header='Id,Category',
delimiter=',',
comments='')
import numpy as np
print("Module imports successful.")
# import images
# full_path = ""~/CS/Hydroponic-Root-Classifier/"
test_image = cv.imread("allData/1_a.jpg")
print(test_image.shape)
preprocess_input(test_image) # doesn't change input dimensions
# build pre-trained xception model
model = Xception(include_top=False,
weights='imagenet',
input_tensor=None,
input_shape=(256, 256, 3),
pooling=None)
# expand x to the 4-dimensional tensor (batch_size, image_width, image_height, channels)
# required by the Xception model as input
test_image = np.expand_dims(test_image, axis=0)
# use xception model to make prediction for images
predictions = model.predict(test_image, batch_size=1, verbose=0, steps=None)
print("Prediction completed.")
print(predictions.shape)
