# -*- coding: utf-8 -*-
'''Inception-ResNet-v2 model for Keras.
'''
from __future__ import print_function
import numpy as np
import warnings
from keras.layers import Input
from keras import layers
from keras.preprocessing import image
from keras.applications.imagenet_utils import decode_predictions
from keras.applications.inception_resnet_v2 import InceptionResNetV2, preprocess_input
if __name__ == '__main__':
model = InceptionResNetV2(include_top=True, weights='imagenet')
img_path = 'data\\dogscats\\train\\cats\\cat.10013.jpg'
img = image.load_img(img_path, target_size=(299, 299))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
print('Input image shape:', x.shape)
preds = model.predict(x)
print('Predicted:', decode_predictions(preds)) # ('n02123394', 'Persian_cat', 0.94211012)
plt.plot(epochs, val_acc, 'blue', label='Validation acc')
plt.legend()
plt.figure()
plt.title('Training and validation loss')
plt.plot(epochs, loss, 'red', label='Training loss')
plt.plot(epochs, val_loss, 'blue', label='Validation loss')
plt.legend()
plt.show()
import time
import numpy as np
from keras.preprocessing import image
test_image = image.load_img(
'/home/vanish/prgs/MLandDL/MITIndoor/Dataset/trainingset/bathroom/b1.jpg',
target_size=(200, 200))
test_image = image.img_to_array(test_image)
test_image = np.expand_dims(test_image, axis=0)
test_image = preprocess_input(test_image) # added to check same preds issue
start_time = time.time()
result = model.predict(test_image)
#decode_predictions(result)
print("--- %s seconds ---" % (time.time() - start_time))
for i in range(0, dict.__len__()):
if result[0][i] >= 0.05:
listOfKeys = [key for (key, value) in dict.items() if value == i]
for key in listOfKeys:
print(key)
break
def extract_InceptionResV2(tensor):
return pretrained_model('InceptionResNetV2').predict(preprocess_input(tensor))
def run(self):
# set enviornment
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = str(self.gpuid)
print("InferenceWorker init, GPU ID: {}".format(self.gpuid))
from Base.model import build_model
# load models
model_weights_path = 'models/model.00-0.0296.hdf5'
model = build_model()
model.load_weights(model_weights_path)
while True:
try:
try:
item = self.in_queue.get(block=False)
except queue.Empty:
continue
image_name_0, image_name_1, image_name_2 = item
filename = os.path.join(image_folder, image_name_0)
image_bgr = cv.imread(filename)
image_bgr = cv.resize(image_bgr, (img_size, img_size),
cv.INTER_CUBIC)
image_rgb = cv.cvtColor(image_bgr, cv.COLOR_BGR2RGB)
image_rgb_0 = preprocess_input(image_rgb)
filename = os.path.join(image_folder, image_name_1)
image_bgr = cv.imread(filename)
image_bgr = cv.resize(image_bgr, (img_size, img_size),
cv.INTER_CUBIC)
image_rgb = cv.cvtColor(image_bgr, cv.COLOR_BGR2RGB)
image_rgb_1 = preprocess_input(image_rgb)
filename = os.path.join(image_folder, image_name_2)
image_bgr = cv.imread(filename)
image_bgr = cv.resize(image_bgr, (img_size, img_size),
cv.INTER_CUBIC)
image_rgb = cv.cvtColor(image_bgr, cv.COLOR_BGR2RGB)
image_rgb_2 = preprocess_input(image_rgb)
batch_inputs = np.empty((3, 1, img_size, img_size, 3),
dtype=np.float32)
batch_inputs[0] = image_rgb_0
batch_inputs[1] = image_rgb_1
batch_inputs[2] = image_rgb_2
y_pred = model.predict(
[batch_inputs[0], batch_inputs[1], batch_inputs[2]])
a = y_pred[0, 0:128]
p = y_pred[0, 128:256]
n = y_pred[0, 256:384]
self.out_queue.put({
'image_name': image_name_0,
'embedding': a
})
self.out_queue.put({
'image_name': image_name_1,
'embedding': p
})
self.out_queue.put({
'image_name': image_name_2,
'embedding': n
})
if self.in_queue.qsize() == 0:
break
except Exception as e:
print(e)
import keras.backend as K
K.clear_session()
print('InferenceWorker done, GPU ID {}'.format(self.gpuid))
No_Forgery_train_Labels = No_Genuine_train_Labels
No_Genuine_test_Labels = No_of_Users * No_testing_samples_per_User
No_Forgery_test_Labels = No_Genuine_test_Labels
print(No_Genuine_train_Labels)
print(No_Forgery_train_Labels)
print(No_Genuine_test_Labels)
print(No_Forgery_test_Labels)
#################################################################################################################################################
for photo in Final_train_List:
#print(photo)
img = image.load_img(photo, target_size=(img_width, img_height))
tr_x = image.img_to_array(img)
tr_x = preprocess_input(tr_x)
Final_train_List3.append(tr_x)
for photo in Final_test_List:
#print(photo)
img = image.load_img(photo, target_size=(img_width, img_height))
tr_x = image.img_to_array(img)
tr_x = preprocess_input(tr_x)
Final_test_List3.append(tr_x)
############################################################################################################
###############################################################################################################################
for i in range(0,No_Genuine_train_Labels):
Y_train.append(0)
for i in range(No_Forgery_train_Labels):
Y_train.append(1)
Y_train = np.array(Y_train)
# load an image in PIL format
try:
img = image.load_img(img_name,
target_size=(img_width, img_height))
except:
print("skips as it is broken")
print(f_idx, fname)
images_broken_idx[f_idx] = True
img = PIL.Image.new(mode="RGB",
size=(img_width, img_height))
img = image.img_to_array(img)
img = np.expand_dims(img, axis=0)
# prepare the image (normalisation for channels)
img_preprocessed = inception_resnet_v2.preprocess_input(
img.copy())
images.append(img_preprocessed)
# vstack for batch tagging
images_vstack = np.vstack(images)
# stack up images list to pass for prediction
predictions = model_trained.predict(images_vstack,
batch_size=bsize_tmp)
# predictions.shape
## top selected classes
top_classes_idx_arr = np.argsort(predictions)[:, ::-1][:, :top]
top_classes_arr = classes_arr[top_classes_idx_arr]
def GetDataGenerator(dataloader):
while True:
for images, labels in dataloader:
images = preprocess_input(images)
labels = keras.utils.to_categorical(labels, cfg.num_classes)
yield (images, labels)
# Reading the images
image_1 = cv2.resize(cv2.imread(image_1_path, 1), (299, 299))
image_2 = cv2.resize(cv2.imread(image_2_path, 1), (299, 299))
image_3 = cv2.resize(cv2.imread(image_3_path, 1), (299, 299))
# Creating a copy of the images for displaying purpose
image_1_copy = image_1
image_2_copy = image_2
image_3_copy = image_3
# Pre-processing the input
image_1 = np.expand_dims(image_1, axis=0)
image_2 = np.expand_dims(image_2, axis=0)
image_3 = np.expand_dims(image_3, axis=0)
image_1 = preprocess_input(image_1)
image_2 = preprocess_input(image_2)
image_3 = preprocess_input(image_3)
# Loading the model
my_model = incpt(weights='imagenet')
# Model Summary
# my_model.summary()
cv2.imshow("Cat", image_1_copy)
cv2.waitKey(0)
print("Predicted:", decode_predictions(my_model.predict(image_1), top=3)[0])
cv2.imshow("Moon", image_2_copy)
cv2.waitKey(0)
def preproc_input_classifcation(img):
from keras.applications.inception_resnet_v2 import preprocess_input
return preprocess_input(img)
# -*- coding: utf-8 -*- """ Created on Sun Sep 29 16:40:26 2019 @author: Jianmu """ from keras.applications.inception_resnet_v2 import InceptionResNetV2, preprocess_input, decode_predictions from keras.preprocessing.image import load_img, img_to_array import numpy as np #%% model = InceptionResNetV2() print(model.summary()) #%% target_size = (299, 299) img_path = "C:/Users/14534/Desktop/4.jpg" image = load_img(img_path, target_size=target_size) image_data = img_to_array(image) #image_data = image_data.reshape((1,) + image_data.shape) image_data = np.expand_dims(image_data, axis=0) print(image_data.shape) image_data = preprocess_input(image_data) #%% prediction = model.predict(image_data) results = decode_predictions(prediction, top=3) print(results)
def main():
'''
A script which can visualize picture's embedding
'''
# ================================================
# Load pre-trained model and remove higher level layers
# ================================================
print("Loading inception_resnet_v2 pre-trained model...")
model = InceptionResNetV2(weights='imagenet', include_top=False)
# ================================================
# Read images and convert them to feature vectors
# ================================================
img_list, filename_heads = [], []
path = "db"
print("Reading images from '{}' directory...\n".format(path))
for index, file_path in enumerate(Path(path).iterdir()):
if index == 50:
break
# Process filename
head, ext = file_path.name, file_path.suffix
if ext.lower() not in [".jpg", ".jpeg"]:
continue
# Read image file
img = image.load_img(str(file_path), target_size=(224, 224)) # load
filename_heads.append(head) # filename head
# Pre-process for model input
# keras's numpy format is float32
img = image.img_to_array(img) # convert to array
img = np.expand_dims(img, axis=0)
if len(img_list) > 0:
img_list = np.concatenate((img_list, img))
else:
img_list = img
img_list = preprocess_input(img_list)
predicts = model.predict(img_list).reshape(len(img_list), -1)
img_list = img_list.astype('uint8')
print("img_list.shape = {}".format(img_list.shape))
print("X_features.shape = {}\n".format(predicts.shape))
# ===========================
# Find k-nearest images to each image
# ===========================
n_neighbours = 5 + 1 # +1 as itself is most similar
knn = kNN() # kNN model
knn.compile(n_neighbors=n_neighbours, algorithm="brute", metric="cosine")
knn.fit(predicts)
# ==================================================
# Plot recommendations for each image in database
# ==================================================
output_rec_dir = Path('output', 'rec')
if not output_rec_dir.exists():
output_rec_dir.mkdir()
n_imgs = int(len(img_list) / 5)
ypixels, xpixels = img_list[0].shape[0], img_list[0].shape[1]
for ind_query in range(n_imgs):
# Find top-k closest image feature vectors to each vector
print("[{}/{}] Plotting similar image recommendations \
for: {}".format(ind_query + 1, n_imgs, filename_heads[ind_query]))
distances, indices = knn.predict(np.array([predicts[ind_query]]))
distances = distances.flatten()
indices = indices.flatten()
indices, distances = find_topk_unique(indices, distances, n_neighbours)
# Plot recommendations
rec_filename = Path(output_rec_dir,
"{}_rec.png".format(filename_heads[ind_query]))
x_query_plot = img_list[ind_query].reshape((-1, ypixels, xpixels, 3))
x_answer_plot = img_list[indices].reshape((-1, ypixels, xpixels, 3))
plot_query_answer(
x_query=x_query_plot,
x_answer=x_answer_plot[1:], # remove itself
filename=str(rec_filename))
# ===========================
# Plot tSNE
# ===========================
output_tsne_dir = Path("output")
if not output_tsne_dir.exists():
output_tsne_dir.mkdir()
tsne_filename = Path(output_tsne_dir, "tsne.png")
print("Plotting tSNE to {}...".format(tsne_filename))
plot_tsne(img_list, predicts, str(tsne_filename))
## create unlabeled synthetic samples as Cohort I
FC_features = np.random.rand(261, 90, 90, 3)
SC_features = np.random.rand(261, 90, 90, 3)
## load VGG pretrained network
base_model = VGG19(include_top=False,
weights='imagenet',
input_shape=(90, 90, 3))
TL_model = Model(inputs=base_model.input, outputs=base_model.output)
for layer in TL_model.layers:
layer.trainable = False
## dimension reduction with VGG to the same size as target cohort
FC_train = preprocess_input(FC_features)
SC_train = preprocess_input(SC_features)
FC_train = TL_model.predict(FC_train)
SC_train = TL_model.predict(SC_train)
## flatten connectome
FC_train_flat = FC_train.reshape(
(FC_train.shape[0],
FC_train.shape[1] * FC_train.shape[2] * FC_train.shape[3]))
SC_train_flat = SC_train.reshape(
(SC_train.shape[0],
SC_train.shape[1] * SC_train.shape[2] * SC_train.shape[3]))
## train SSAE using cohort II in an unsupervised learning
## the number of nodes in first and second layer should match to deep multimodal learning
x = Dropout(0.75)(base_model.output)
x = Dense(10, activation='softmax')(x)
model = Model(base_model.input, x)
model.load_weights('weights/inception_resnet_weights.h5')
score_list = np.empty((len(imgs), 11), dtype=object)
step = 20000
i = 0
while i < len(imgs):
print(i)
imgs_temp = imgs[i:i + step]
img_array = np.empty((len(imgs_temp), 224, 224, 3))
file_names = []
for ind, j in tqdm.tqdm(enumerate(imgs_temp)):
x = preprocess_input(np.expand_dims(img_to_array(load_img(j, target_size=target_size)), axis=0))
img_array[ind, ] = x
file_names.append(Path(j).name.lower())
scores = model.predict(img_array, batch_size=100, verbose=0)
#si = np.arange(1, 11, 1)
#mean = np.sum(scores * si, axis=1)
#std = np.sqrt(np.sum(((np.array([si, ] * len(imgs_temp)) - mean.reshape(len(imgs_temp), -1)) ** 2) * scores, axis=1))
#result = np.stack([file_names, mean, std]).transpose()
#result = np.stack([file_names, scores]).transpose()
#score_list[i:i + step, ] = result
score_list[i:i + step, 0] = file_names
def predict_scores(self, frames, model, start):
# frames = tf.convert_to_tensor(frames, dtype=tf.float32)
frames = preprocess_input(frames.astype(np.float32))
scores = model.predict(frames, batch_size=1, verbose=1)
means = self.mean_score(scores)
return (np.max(means), np.argmax(means) + start)
def calculate_mode_score(gen_images_path,
real_images_path,
batch_size=32,
splits=10):
# Create an instance of InceptionV3
model = InceptionResNetV2()
# Load real images
real_images = None
for image_ in glob.glob(real_images_path):
# Load image
loaded_image = image.load_img(image_, target_size=(299, 299))
# Convert PIL image to numpy ndarray
loaded_image = image.img_to_array(loaded_image)
# Another another dimension (Add batch dimension)
loaded_image = np.expand_dims(loaded_image, axis=0)
# Concatenate all images into one tensor
if real_images is None:
real_images = loaded_image
else:
real_images = np.concatenate([real_images, loaded_image], axis=0)
# Load generated images
gen_images = None
for image_ in glob.glob(gen_images_path):
# Load image
loaded_image = image.load_img(image_, target_size=(299, 299))
# Convert PIL image to numpy ndarray
loaded_image = image.img_to_array(loaded_image)
# Another another dimension (Add batch dimension)
loaded_image = np.expand_dims(loaded_image, axis=0)
# Concatenate all images into one tensor
if gen_images is None:
gen_images = loaded_image
else:
gen_images = np.concatenate([gen_images, loaded_image], axis=0)
# Calculate number of batches for generated images
gen_num_batches = (gen_images.shape[0] + batch_size - 1) // batch_size
gen_images_probs = None
# Use InceptionV3 to calculate probabilities of generated images
for i in range(gen_num_batches):
image_batch = gen_images[i * batch_size:(i + 1) * batch_size, :, :, :]
prob = model.predict(preprocess_input(image_batch))
if gen_images_probs is None:
gen_images_probs = prob
else:
gen_images_probs = np.concatenate([prob, gen_images_probs], axis=0)
# Calculate number of batches for real images
real_num_batches = (real_images.shape[0] + batch_size - 1) // batch_size
real_images_probs = None
# Use InceptionV3 to calculate probabilities of real images
for i in range(real_num_batches):
image_batch = real_images[i * batch_size:(i + 1) * batch_size, :, :, :]
prob = model.predict(preprocess_input(image_batch))
if real_images_probs is None:
real_images_probs = prob
else:
real_images_probs = np.concatenate([prob, real_images_probs],
axis=0)
# KL-Divergence: compute kl-divergence and mean of it
num_gen_images = len(gen_images)
split_scores = []
for j in range(splits):
gen_part = gen_images_probs[j * (num_gen_images // splits):(j + 1) *
(num_gen_images // splits), :]
real_part = real_images_probs[j * (num_gen_images // splits):(j + 1) *
(num_gen_images // splits), :]
gen_py = np.mean(gen_part, axis=0)
real_py = np.mean(real_part, axis=0)
scores = []
for i in range(gen_part.shape[0]):
scores.append(entropy(gen_part[i, :], gen_py))
split_scores.append(np.exp(np.mean(scores) - entropy(gen_py, real_py)))
final_mean = np.mean(split_scores)
final_std = np.std(split_scores)
return final_mean, final_std
from time import time
import numpy as np
from keras.applications.inception_resnet_v2 import InceptionResNetV2
from keras.applications.inception_resnet_v2 import preprocess_input
from keras.applications.inception_resnet_v2 import decode_predictions
from skimage.io import imread
from skimage.transform import resize
tic = time()
model = InceptionResNetV2(weights='imagenet')
print("Loaded model in {:.3}s".format(time() - tic))
image = imread('laptop.jpeg')
image_resized = resize(image, (299, 299), preserve_range=True, mode='reflect')
image_resized_batch = np.expand_dims(image_resized, axis=0)
tic = time()
preds = model.predict(preprocess_input(image_resized_batch))
print("Computed predictions in {:.3}s".format(time() - tic))
print('Predicted image labels:')
class_names, confidences = [], []
for class_id, class_name, confidence in decode_predictions(preds, top=5)[0]:
print(" {} (synset: {}): {:0.3f}".format(class_name, class_id,
confidence))
for j, k in enumerate(prediction[0]):
if k >= min_score:
o[labels[j]] = float(k)
output.append(o)
return output
for kf in glob.glob('data/raw/*'):
klass = os.path.basename(kf)
total = 0
correct = 0
wrong_klasses = set()
for image_paths in chunk(glob.glob('data/raw/' + klass + '/*'), 139):
images = []
for image_path in image_paths:
try:
img = preprocess_input(load_image(image_path))
images.append(img)
total += 1
except OSError:
print("error processing", image_path)
for output in predict(images):
if klass in output and output[klass] >= 0.5:
correct += 1
wrong_klasses |= set(output.keys())
wrong_klasses.discard(klass)
print(klass + ': ' + str(correct) + '/' + str(total))
print(' wrong classes: ', ', '.join(wrong_klasses))
print()
def inception_resnet_v2_predict(images):
images = images.astype(np.float32)
predictions = model.predict(preprocess_input(images))
return predictions
y = np.argmax(predictions, axis=-1)
print(y)
print('Classification Report')
cr = classification_report(y_true=validation_generator.classes, y_pred=y)
print(cr)
print('Confusion Matrix')
plt.clf()
cm = confusion_matrix(validation_generator.classes, y)
df = pd.DataFrame(cm, columns=validation_generator.class_indices)
plt.figure(figsize=(80, 80))
sn.heatmap(df, annot=True)
plt.savefig('./cm.png')
####################### Classify random img
imageno = np.random.random_integers(low=0, high=validation_generator.samples)
name = validation_generator.filepaths[imageno]
print(name)
plt.imshow(mpimg.imread(name))
img = Image.open(validation_generator.filepaths[imageno]).resize((224, 224))
probabilities = model.predict(preprocess_input(np.expand_dims(img, axis=0)))
breed_list = tuple(
zip(validation_generator.class_indices.values(),
validation_generator.class_indices.keys()))
for i in probabilities[0].argsort()[-3:][::-1]:
print(probabilities[0][i], " : ", breed_list[i])
def save_bottlebeck_features(model_name):
if model_name == 'resnet50':
model = resnet50.ResNet50(weights='imagenet',
include_top=False,
pooling='avg')
feat_output = [
'E:/Hongming/projects/tcga-bladder-mutationburden/feature_output/P_CN_20X/2)resnet50/',
'E:/Hongming/projects/tcga-bladder-mutationburden/feature_output/P_CN_20X/2)resnet50/'
]
# 2048 dimensional features
# pooling: 1) None: output is 16x16x2048, 2) avg: 1x1x2048, 3) max: 1x1x2048
#base_model=resnet50.ResNet50(input_shape=(img_height,img_width,3),weights='imagenet', include_top=False)
#model = Model(inputs=base_model.input, outputs=base_model.get_layer('activation_25').output)
elif model_name == 'nasnet_large':
model = nasnet.NASNetLarge(input_shape=(img_height, img_width, 3),
weights='imagenet',
include_top=False,
pooling='avg')
#4032 dimensional features
elif model_name == 'xception':
model = xception.Xception(input_shape=(img_height, img_width, 3),
weights='imagenet',
include_top=False,
pooling='avg')
feat_output = [
'E:/Hongming/projects/tcga-bladder-mutationburden/feature_output/P_CN_20X/4)xception/',
'E:/Hongming/projects/tcga-bladder-mutationburden/feature_output/P_CN_20X/4)xception/'
]
#2048 dimensional features
elif model_name == 'inceptionv3':
model = inception_v3.InceptionV3(input_shape=(img_height, img_width,
3),
weights='imagenet',
include_top=False,
pooling='avg')
feat_output = [
'E:/Hongming/projects/tcga-bladder-mutationburden/feature_output/P_CN_20X/5)inceptionv3/',
'E:/Hongming/projects/tcga-bladder-mutationburden/feature_output/P_CN_20X/5)inceptionv3/'
]
#2048 dimensional features
elif model_name == 'inceptionresnetv2':
model = inception_resnet_v2.InceptionResNetV2(input_shape=(img_height,
img_width,
3),
weights='imagenet',
include_top=False,
pooling='avg')
#1536 dimensional features
elif model_name == 'densenet':
model = densenet.DenseNet201(input_shape=(img_height, img_width, 3),
weights='imagenet',
include_top=False,
pooling='avg')
# 1920 dimensional features
else:
model = vgg19.VGG19(weights='imagenet',
include_top=False,
pooling='avg')
# 512 dimensional features
#base_model=vgg19.VGG19(input_shape=(img_height,img_width,3),weights='imagenet', include_top=False)
#model=Model(inputs=base_model.input,outputs=base_model.get_layer('block4_pool').output)
#for i,layer in enumerate(model.layers):
# print(i,layer.name)
#print(model.summary())
for ind in range(1, len(img_path)):
path_ind = img_path[ind]
#path_split=path_ind.split("/")
images = os.listdir(path_ind)
for image_name in images:
if '.svs' in image_name:
patient_id = image_name[0:23]
image_features = []
image_names = []
ss = time.time()
patient_id = 'TCGA-2F-A9KO'
#patches=os.listdir(train_data_dir[ind]+patient_id+'*.png')
patches = glob.glob(train_data_dir[0] + patient_id + '*.png')
for patch_name in patches:
patch_split = patch_name.split("\\")
img = image.load_img(patch_name,
target_size=(img_height, img_width))
# convert image to numpy array
x = image.img_to_array(img)
# the image is now in an array of shape (224, 224, 3)
# need to expand it to (1, 224, 224, 3) as it's expecting a list
x = np.expand_dims(x, axis=0)
#imshow(np.uint8(x[0,:,:,:]))
if model_name == 'resnet50':
x = resnet50.preprocess_input(x)
elif model_name == 'nasnet_large':
x = nasnet.preprocess_input(x)
elif model_name == 'xception':
x = xception.preprocess_input(x)
elif model_name == 'inceptionv3':
x = inception_v3.preprocess_input(x)
elif model_name == 'inceptionresnetv2':
x = inception_resnet_v2.preprocess_input(x)
elif model_name == 'densenet':
x = densenet.preprocess_input(x)
else:
x = vgg19.preprocess_input(x)
# extract the features
features = model.predict(x)[0]
#features=np.mean(features,axis=(0,1))
image_features.append(features)
image_names.append(patch_split[1])
se = time.time() - ss
print(se)
if save_features == True:
scipy.io.savemat(feat_output[ind] + patient_id +
'_feat.mat',
mdict={
'image_features': image_features,
'image_names': image_names
})
def my_TTA(img):
# Set the indication if new whale predicted already for this picture to false.
# Set the place to put the new_whale predication to the end of the list(ignored there).
# Preprocess the image before insert it into the predic model.
Is_new_whale = False
new_whale_location = NUMBER_OF_PREDICATIONS
x = image.img_to_array(img)
# Augmentation for the picture as described.
original_img = np.array(x)
original_img = np.expand_dims(original_img, axis=0)
original_img = preprocess_input(original_img)
predictions_orig = model.predict(original_img, verbose=0)
flip_img = np.array(Augmentation_Scale_Trans_Flip_Blur(np.array(x)))
flip_img = np.expand_dims(flip_img, axis=0)
flip_img = preprocess_input(flip_img)
predictions_flip = model.predict(flip_img, verbose=0)
fliplr_img = np.fliplr(np.array(x))
fliplr_img = np.expand_dims(fliplr_img, axis=0)
fliplr_img = preprocess_input(fliplr_img)
predictions_fliplr = model.predict(fliplr_img, verbose=0)
flipud_img = np.array(Augmentation_Scale_Trans_Flip_Blur(np.array(x)))
flipud_img = np.expand_dims(flipud_img, axis=0)
flipud_img = preprocess_input(flipud_img)
predictions_flipud = model.predict(flipud_img, verbose=0)
# The first 5 predictions for each augmentation
predictions_orig_ind = predictions_orig.argsort(
)[0][::-1][:NUMBER_OF_PREDICATIONS]
predictions_flip_ind = predictions_flip.argsort(
)[0][::-1][:NUMBER_OF_PREDICATIONS]
predictions_fliplr_ind = predictions_fliplr.argsort(
)[0][::-1][:NUMBER_OF_PREDICATIONS]
predictions_flipud_ind = predictions_flipud.argsort(
)[0][::-1][:NUMBER_OF_PREDICATIONS]
llist = []
Best_guess_list = []
Index_list = [0, 0, 0, 0]
# For each picture find the correct prediction according the described logic.
for i in range(NUMBER_OF_PREDICATIONS):
llist = [predictions_orig_ind[Index_list[0]], predictions_flip_ind[Index_list[1]], \
predictions_fliplr_ind[Index_list[2]], predictions_flipud_ind[Index_list[3]]]
max_pred_num = [predictions_orig[0][Index_list[0]], predictions_flip[0][Index_list[1]], \
predictions_fliplr[0][Index_list[2]], predictions_flipud[0][Index_list[3]]]
max_pred_value = max_pred_num[max_pred_num.index(
max(max_pred_num))]
# If the prediction is not above the threshold than put a new_whale classification in that spot
# and ignore futher classifiaction below the thresholf for that picture.
if not Is_new_whale and max_pred_value < THRESHOLD:
Is_new_whale = True
new_whale_location = i
# If there are more than one prediction agreement on the classification, choose this classification,
# otherwise choose the highest prediction.
if Most_common_count(llist) > 1:
Best_guess_list.append(Most_common_element(llist))
Index_list[Index_of_value(llist,
Most_common_element(llist))] += 1
else:
Best_guess_list.append(max_pred_num.index(max_pred_value))
Index_list[max_pred_num.index(max_pred_value)] += 1
# Insert the 'new_whale' classification into the predictions.
if Is_new_whale:
Best_guess_list.insert(new_whale_location, NEW_WHALE_INDEX)
del Best_guess_list[-1]
return (Best_guess_list)
# convert image to 3D tensor with shape (299, 299, 3)
x = image.img_to_array(img)
# convert 3D tensor to 4D tensor with shape (1, 299, 299, 3)
return np.expand_dims(x, axis=0)
def paths_to_tensor(img_paths):
list_of_tensors = [
path_to_tensor(img_path) for img_path in tqdm(img_paths)
]
return np.vstack(list_of_tensors)
from PIL import ImageFile
ImageFile.LOAD_TRUNCATED_IMAGES = True
# pre-process the data for Keras
train_tensors = paths_to_tensor(train_files)
test_tensors = paths_to_tensor(test_files)
# load InceptionResNet V2 model
from keras.applications.inception_resnet_v2 import InceptionResNetV2, preprocess_input
model = InceptionResNetV2(include_top=False, weights='imagenet')
# preprocess the tensors and get bottleneck_features
# These codes take a long time. It's better to use GPU/cloud services
bottleneck_features_train = model.predict(preprocess_input(train_tensors))
np.save(open('bottleneck_features_train.npy', 'w'), bottleneck_features_train)
bottleneck_features_test = model.predict(preprocess_input(test_tensors))
np.save(open('bottleneck_features_test.npy', 'w'), bottleneck_features_test)
# @todo skip readily done files.
# convert the PIL image to a numpy array
# IN PIL - image is in (width, height, channel)
# In Numpy - image is in (height, width, channel)
numpy_image = img_to_array(original)
# Convert the image / images into batch format
# expand_dims will add an extra dimension to the data at a particular axis
# We want the input matrix to the network to be of the form (batchsize, height, width, channels)
# Thus we add the extra dimension to the axis 0.
image_batch = np.expand_dims(numpy_image, axis=0)
# prepare the image (normalisation for channels)
processed_image = inception_resnet_v2.preprocess_input(
image_batch.copy())
# get the predicted probabilities for each class
# @todo predict_on_batch
predictions = model_trained.predict(processed_image)
# print predictions
dominant_feature_idx = np.argmax(predictions[0])
# This is the dominant entry in the prediction vector
dominant_output = model_trained.output[:, dominant_feature_idx]
# convert the probabilities to class labels
predicted_class = classes[dominant_feature_idx]
print('Predicted:', predicted_class)
def make_transfer_prediction(tensor):
with K.get_session().graph.as_default() as g:
return transfer_model.predict(preprocess_input(tensor))
def preprocess(x):
x = eraser(x)
x = preprocess_input(x)
return x
def preproc_glaucoma(img):
glauc_a = glaucoma(img)
final = preprocess_input(glauc_a)
return final
with tf.device('/GPU:0'):
base_model = InceptionResNetV2(input_shape=(None, None, 3), include_top=False, pooling='avg', weights=None)
x = Dropout(0.75)(base_model.output)
x = Dense(10, activation='softmax')(x)
model = Model(base_model.input, x)
model.load_weights('weights/inception_resnet_weights.h5')
score_list = []
for img_path in imgs:
img = load_img(img_path, target_size=target_size)
x = img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
scores = model.predict(x, batch_size=1, verbose=0)[0]
mean = mean_score(scores)
std = std_score(scores)
file_name = Path(img_path).name.lower()
score_list.append((file_name, mean))
# print("Evaluating : ", img_path)
# print("NIMA Score : %0.3f +- (%0.3f)" % (mean, std))
# print()
if rank_images:
# print("*" * 40, "Ranking Images", "*" * 40)
def preproc_amd(img):
amd_a = amd(img)
final = preprocess_input(amd_a)
return final
from time import time
import numpy as np
from keras.applications.inception_resnet_v2 import InceptionResNetV2
from keras.applications.inception_resnet_v2 import preprocess_input
from keras.applications.inception_resnet_v2 import decode_predictions
from skimage.io import imread
from skimage.transform import resize
tic = time()
model = InceptionResNetV2(weights='imagenet')
print("Loaded model in {:.3}s".format(time() - tic))
image = imread('laptop.jpeg')
image_resized = resize(image, (299, 299), preserve_range=True, mode='reflect')
image_resized_batch = np.expand_dims(image_resized, axis=0)
tic = time()
preds = model.predict(preprocess_input(image_resized_batch))
print("Computed predictions in {:.3}s".format(time() - tic))
print('Predicted image labels:')
class_names, confidences = [], []
for class_id, class_name, confidence in decode_predictions(preds, top=5)[0]:
print(" {} (synset: {}): {:0.3f}".format(class_name, class_id, confidence))
def preproc_diabeticRet(img):
dr_a = diabeticRet(img)
final = preprocess_input(dr_a)
return final
from keras.preprocessing.sequence import pad_sequences
from keras.models import Model
from keras.utils import to_categorical
from keras.layers import Embedding, TimeDistributed, RepeatVector, LSTM, concatenate , Input, Reshape, Dense, Flatten
from keras.preprocessing.image import array_to_img, img_to_array, load_img
from keras.applications.inception_resnet_v2 import InceptionResNetV2, preprocess_input
import numpy as np
# Load the images and preprocess them for inception-resnet
images = []
all_filenames = listdir('images/')
all_filenames.sort()
for filename in all_filenames:
images.append(img_to_array(load_img('images/'+filename, target_size=(299, 299))))
images = np.array(images, dtype=float)
images = preprocess_input(images)
# Run the images through inception-resnet and extract the features without the classification layer
IR2 = InceptionResNetV2(weights='imagenet', include_top=False)
features = IR2.predict(images)
# We will cap each input sequence to 100 tokens
max_caption_len = 100
# Initialize the function that will create our vocabulary
tokenizer = Tokenizer(filters='', split=" ", lower=False)
# Read a document and return a string
def load_doc(filename):
file = open(filename, 'r')
text = file.read()
file.close()
def preprocess_image(img):
Image = image.load_img("train/" + img + ".jpg", target_size=(299, 299))
data = image.img_to_array(Image)
data = preprocess_input(data)
return data
