def data_generator(data, batch_size): # 样本生成器，节省内存
while True:
batch = np.random.choice(data, batch_size)
tx, ty = [], []
for img in batch:
# pic = Image.open(directory + img) # .convert('L')
# pic = misc.imresize(pic, img_size)
# if pic.shape == (200, 200):
# pic = cv2.cvtColor(pic.reshape(200, 200), cv2.COLOR_GRAY2BGR)
# pic = misc.imresize(pic, img_size)
pic = load_img(directory + img, target_size=(200, 200))
pic = img_to_array(pic)
pic = pic.reshape((pic.shape[0], pic.shape[1], pic.shape[2]))
tx.append(pic)
ty.append(y[img])
# for i in tx:
# print(i.shape)
tyy = []
for i in ty:
yy = np.zeros((230,))
yy[label_list.index(i)] = 1
tyy.append(yy)
ty = np.array(tyy)
tx = preprocess_input(np.array(tx).astype(float))
yield tx, ty
def test_prediction_vs_tensorflow_inceptionV3(self):
output_col = "prediction"
image_df = image_utils.getSampleImageDF()
# An example of how a pre-trained keras model can be used with TFImageTransformer
with KSessionWrap() as (sess, g):
with g.as_default():
K.set_learning_phase(0) # this is important but it's on the user to call it.
# nChannels needed for input_tensor in the InceptionV3 call below
image_string = utils.imageInputPlaceholder(nChannels = 3)
resized_images = tf.image.resize_images(image_string,
InceptionV3Constants.INPUT_SHAPE)
preprocessed = preprocess_input(resized_images)
model = InceptionV3(input_tensor=preprocessed, weights="imagenet")
graph = tfx.strip_and_freeze_until([model.output], g, sess, return_graph=True)
transformer = TFImageTransformer(inputCol="image", outputCol=output_col, graph=graph,
inputTensor=image_string, outputTensor=model.output,
outputMode="vector")
transformed_df = transformer.transform(image_df.limit(10))
self.assertDfHasCols(transformed_df, [output_col])
collected = transformed_df.collect()
transformer_values, transformer_topK = self.transformOutputToComparables(collected,
"filePath",
output_col)
tf_values, tf_topK = self._executeTensorflow(graph, image_string.name, model.output.name,
image_df)
self.compareClassSets(tf_topK, transformer_topK)
self.compareClassOrderings(tf_topK, transformer_topK)
self.compareArrays(tf_values, transformer_values)
def predict(image_file):
img = image.load_img(image_file, target_size=(img_width,img_height))
x = image.img_to_array(img)
x = np.expand_dims(x,axis=0)
x = preprocess_input(x)
preds = model.predict(x)
return preds
def test_spimage_converter_module(self):
""" spimage converter module must preserve original image """
img_fpaths = glob(os.path.join(_getSampleJPEGDir(), '*.jpg'))
def exec_gfn_spimg_decode(spimg_dict, img_dtype):
gfn = gfac.buildSpImageConverter(img_dtype)
with IsolatedSession() as issn:
feeds, fetches = issn.importGraphFunction(gfn, prefix="")
feed_dict = dict((tnsr, spimg_dict[tfx.op_name(issn.graph, tnsr)]) for tnsr in feeds)
img_out = issn.run(fetches[0], feed_dict=feed_dict)
return img_out
def check_image_round_trip(img_arr):
spimg_dict = imageArrayToStruct(img_arr).asDict()
spimg_dict['data'] = bytes(spimg_dict['data'])
img_arr_out = exec_gfn_spimg_decode(spimg_dict, spimg_dict['mode'])
self.assertTrue(np.all(img_arr_out == img_arr))
for fp in img_fpaths:
img = load_img(fp)
img_arr_byte = img_to_array(img).astype(np.uint8)
check_image_round_trip(img_arr_byte)
img_arr_float = img_to_array(img).astype(np.float)
check_image_round_trip(img_arr_float)
img_arr_preproc = iv3.preprocess_input(img_to_array(img))
check_image_round_trip(img_arr_preproc)
def load_img_and_occuluding(model, path, window_size = (40,40), slide_size = 3, correct_class = 0):
img = image.load_img(path, target_size=(299,299,3))
x = image.img_to_array(img)
x = preprocess_input(x)
plt.imshow(reverse_preprocessing(x))
plt.show()
res = occuluding_img(model, x, window_size, slide_size, correct_class)
return res
def _preprocess_an_image(self, img_path, random_transform=True):
img = load_img(img_path, target_size=self.IMAGE_SIZE)
img_array = img_to_array(img)
if self._image_augmentation_switch and random_transform:
img_array = self._image_data_generator.random_transform(img_array)
img_array = inception_v3.preprocess_input(img_array)
return img_array
def preprocess_image(image_path):
# Util function to open, resize and format pictures
# into appropriate tensors.
img = load_img(image_path)
img = img_to_array(img)
img = np.expand_dims(img, axis=0)
img = inception_v3.preprocess_input(img)
return img
def preprocess_image(path, img_size):
if not os.path.isfile(path):
return np.zeros((1, img_size, img_size, 3), dtype=np.float32)
img = Image.open(path).convert('RGB')
img = img.resize((img_size, img_size))
x = img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
return x
def predict(model, img, target_size):
"""Run model prediction on image
"""
if img.size != target_size:
img = img.resize(target_size)
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
preds = model.predict(x)
return preds[0]
def load_fine_tune_googlenet_v3(img):
# 加载fine-tuning googlenet v3模型，并做预测
model = InceptionV3(include_top=True, weights='imagenet')
model.summary()
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
preds = model.predict(x)
print('Predicted:', decode_predictions(preds))
plt.subplot(212)
plt.plot(preds.ravel())
plt.show()
return model, x
def _buildInceptionV3Session(featurize):
sess = tf.Session()
with sess.as_default():
K.set_learning_phase(0)
inputImage = imageInputPlaceholder(nChannels=3)
preprocessed = inception_v3.preprocess_input(inputImage)
model = InceptionV3(input_tensor=preprocessed, weights="imagenet",
include_top=(not featurize))
return dict(inputTensorName=inputImage.name,
outputTensorName=model.output.name,
session=sess,
inputTensorSize=InceptionV3Constants.INPUT_SHAPE,
outputMode="vector")
def _preprocessingInceptionV3Transformed(self, outputMode, outputCol):
g = tf.Graph()
with g.as_default():
image_arr = utils.imageInputPlaceholder()
resized_images = tf.image.resize_images(image_arr, InceptionV3Constants.INPUT_SHAPE)
processed_images = preprocess_input(resized_images)
self.assertEqual(processed_images.shape[1], InceptionV3Constants.INPUT_SHAPE[0])
self.assertEqual(processed_images.shape[2], InceptionV3Constants.INPUT_SHAPE[1])
transformer = TFImageTransformer(inputCol="image", outputCol=outputCol, graph=g,
inputTensor=image_arr.name, outputTensor=processed_images,
outputMode=outputMode)
image_df = image_utils.getSampleImageDF()
return transformer.transform(image_df.limit(5))
def _preprocessingInceptionV3Transformed(self, outputMode, outputCol):
g = tf.Graph()
with g.as_default():
image_arr = utils.imageInputPlaceholder()
resized_images = tf.image.resize_images(image_arr, InceptionV3Constants.INPUT_SHAPE)
# keras expects array in RGB order, we get it from image schema in BGR => need to flip
processed_images = preprocess_input(imageIO._reverseChannels(resized_images))
self.assertEqual(processed_images.shape[1], InceptionV3Constants.INPUT_SHAPE[0])
self.assertEqual(processed_images.shape[2], InceptionV3Constants.INPUT_SHAPE[1])
transformer = TFImageTransformer(channelOrder='BGR', inputCol="image", outputCol=outputCol, graph=g,
inputTensor=image_arr.name, outputTensor=processed_images,
outputMode=outputMode)
image_df = image_utils.getSampleImageDF()
return transformer.transform(image_df.limit(5))
def predict(image_file):
img = image.load_img(image_file, target_size=(299, 299))
x = image.img_to_array(img)
x = np.expand_dims(x,axis=0)
x = preprocess_input(x)
global graph
with graph.as_default():
preds = model.predict(x)
top3 = decode_predictions(preds,top=3)[0]
predictions = [{'label': label, 'description': description, 'probability': probability * 100.0}
for label,description, probability in top3]
return predictions
def setUpClass(cls):
super(NamedImageTransformerImagenetTest, cls).setUpClass()
# Compute values used by multiple tests.
imgFiles, images = getSampleImageList()
imageArray = np.empty((len(images), 299, 299, 3), 'uint8')
for i, img in enumerate(images):
assert img is not None and img.mode == "RGB"
imageArray[i] = np.array(img.resize((299, 299)))
# Predict the class probabilities for the images in our test library using keras API.
prepedImaged = inception_v3.preprocess_input(imageArray.astype('float32'))
model = inception_v3.InceptionV3()
kerasPredict = model.predict(prepedImaged)
# These values are used by multiple tests so cache them on class setup.
cls.imageArray = imageArray
cls.kerasPredict = kerasPredict
def submit_data_generator(data, path_t):
while True:
tx, ty = [], []
for img in data:
# pic = Image.open(directory + img) # .convert('L')
# pic = misc.imresize(pic, img_size)
# if pic.shape == (200, 200):
# pic = cv2.cvtColor(pic.reshape(200, 200), cv2.COLOR_GRAY2BGR)
# pic = misc.imresize(pic, img_size)
pic = load_img(path_t + img, target_size=(200, 200))
pic = img_to_array(pic)
pic = pic.reshape((pic.shape[0], pic.shape[1], pic.shape[2]))
tx.append(pic)
# print(img)
tx = preprocess_input(np.array(tx).astype(float))
yield tx, ty
def extract(self, image_path):
img = image.load_img(image_path, target_size=(299, 299))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
# Get the prediction.
features = self.model.predict(x)
if self.weights is None:
# For imagenet/default network:
features = features[0]
else:
# For loaded network:
features = features[0]
return features
def predict(model, img, target_size):
"""Run model prediction on image
Args:
model: keras model
img: PIL format image
target_size: (w,h) tuple
Returns:
list of predicted labels and their probabilities
"""
if img.size != target_size:
img = img.resize(target_size)
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
preds = model.predict(x)
return preds[0]
def test_load_image_vs_keras(self):
g = tf.Graph()
with g.as_default():
image_arr = utils.imageInputPlaceholder()
preprocessed = preprocess_input(image_arr)
output_col = "transformed_image"
transformer = TFImageTransformer(inputCol="image", outputCol=output_col, graph=g,
inputTensor=image_arr, outputTensor=preprocessed.name,
outputMode="vector")
image_df = image_utils.getSampleImageDF()
df = transformer.transform(image_df.limit(5))
for row in df.collect():
processed = np.array(row[output_col]).astype(np.float32)
# compare to keras loading
images = self._loadImageViaKeras(row["filePath"])
image = images[0]
image.shape = (1, image.shape[0] * image.shape[1] * image.shape[2])
keras_processed = image[0]
self.assertTrue( (processed == keras_processed).all() )
def test_load_image_vs_keras_RGB(self):
g = tf.Graph()
with g.as_default():
image_arr = utils.imageInputPlaceholder()
# keras expects array in RGB order, we get it from image schema in BGR => need to flip
preprocessed = preprocess_input(image_arr)
output_col = "transformed_image"
transformer = TFImageTransformer(channelOrder='RGB', inputCol="image", outputCol=output_col, graph=g,
inputTensor=image_arr, outputTensor=preprocessed.name,
outputMode="vector")
image_df = image_utils.getSampleImageDF()
df = transformer.transform(image_df.limit(5))
for row in df.collect():
processed = np.array(row[output_col], dtype = np.float32)
# compare to keras loading
images = self._loadImageViaKeras(row["image"]['origin'])
image = images[0]
image.shape = (1, image.shape[0] * image.shape[1] * image.shape[2])
keras_processed = image[0]
np.testing.assert_array_almost_equal(keras_processed, processed, decimal = 6)
def read_image(target_size):
img = image.load_img(img_path, target_size=target_size)
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
return x
def loadAndPreprocessKerasInceptionV3(raw_uri):
# this is the canonical way to load and prep images in keras
uri = raw_uri[5:] if raw_uri.startswith("file:/") else raw_uri
image = img_to_array(load_img(uri, target_size=InceptionV3Constants.INPUT_SHAPE))
image = np.expand_dims(image, axis=0)
return preprocess_input(image)
detections = net.forward()
for i in range(0, detections.shape[2]):
confidence = detections[0, 0, i, 2]
# Setting the confidence to greater than 0.4
if confidence > 0.4:
box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
(startX, startY, endX, endY) = box.astype("int")
(startX, startY) = (max(0, startX), max(0, startY))
(endX, endY) = (min(w - 1, endX), min(h - 1, endY))
# Preprocessing the live feed frame
face = img[startY:endY, startX:endX]
face = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
face = cv2.resize(face, (224, 224))
face = image.img_to_array(face)
face = preprocess_input(face)
face = np.expand_dims(face, axis=0)
# Predicting the frame from the loaded model
(mask, withoutMask) = model.predict(face)[0]
label = "Mask" if mask > withoutMask else "No Mask"
color = (0, 255, 0) if label == "Mask" else (0, 0, 255)
label = "{}: {:.2f}%".format(label, max(mask, withoutMask) * 100)
cv2.putText(img, label, (startX, startY - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
cv2.rectangle(img, (startX, startY), (endX, endY), color, 10)
cv2.imshow("Frame", img)
cv2.imwrite('new_image.jpg', img)
interrupt = cv2.waitKey(10)
def preprocess(self, inputImage):
return inception_v3.preprocess_input(inputImage)
def predict_genre(filename):
img = plt.imread(filename)
text_img = Final_textreader(img)
img_load = image.load_img(filename, target_size=(299, 299))
x = image.img_to_array(img_load)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
start = time.time()
pred_clf_inception = inception_one_image(x) #new_inception prediction
print("Inception done, {}".format(time.time()-start))
#pred_clf_inception = pre_pred_clf_inception.argmax(axis=1)
text_detected = False
features_img = extract_features_keras(x)
features_img_pca = pca.transform(features_img)
pred_clf_svm_inception = clf_SVM_new_inception.predict_proba(features_img_pca) #svm_inception prediction
print("SVM done, {}".format(time.time()-start))
print(text_img)
if text_img == ['']:
# print('Text Mining classifier did not find any text on the image')
total_pred = pd.DataFrame(index=['Top 1', 'Top 2', 'Top 3'],
columns=['inception', 'SVM_inception'])
total_pred_best_pred = pd.DataFrame(index=['Top 1', 'Top 2', 'Top 3'],
columns=['inception', 'SVM_inception'])
total_pred.inception, total_pred_best_pred.inception = classement_predictions(pred_clf_inception)
total_pred.SVM_inception, total_pred_best_pred.SVM_inception = classement_predictions(pred_clf_svm_inception)
else :
# print('Some text has been found on the image: ',text_img)
text_detected = " ".join(text_img)
df_text_img=Corpus_dropna(text_img)
Filtered_text_img=text_processer(df_text_img.Text,stop_words=stopwords,stemmer=None)
Text_img_count=countv.transform(Filtered_text_img)
text_img_to_pred=tformer.transform(Text_img_count)
pred_clf_textmining = clf_Text.predict_proba(text_img_to_pred)#text prediction
print("Text done, {}".format(time.time()-start))
total_pred = pd.DataFrame(index=['Top 1', 'Top 2', 'Top 3'],
columns=['Text', 'inception', 'SVM_inception'])
total_pred_best_pred = pd.DataFrame(index=['Top 1', 'Top 2', 'Top 3'],
columns=['Text', 'inception', 'SVM_inception'])
total_pred.Text, total_pred_best_pred.Text = classement_predictions(pred_clf_textmining)
total_pred.inception, total_pred_best_pred.inception = classement_predictions(pred_clf_inception)
total_pred.SVM_inception, total_pred_best_pred.SVM_inception = classement_predictions(pred_clf_svm_inception)
pred = total_pred_best_pred
resultats=pd.DataFrame(columns=['Best Predictions'],
index=['Top 1', 'Top 2', 'Top 3'])
if(len(pred.columns) == 3):
Top1f=choice_matrix[str(pred.Text[0])][pred.SVM_inception[0]]
if(pred.Text[0]!=pred.SVM_inception[0]):
if(Top1f!=classe[pred.Text[0]]):
Top2f=classe[pred.Text[0]]
else:
Top2f=classe[pred.SVM_inception[0]]
Top2Text=classe[pred.Text[1]]
Top2SVM=classe[pred.SVM_inception[1]]
if(Top2Text!=Top1f and Top2Text!=Top2f):
if(Top2SVM!=Top1f and Top2SVM!=Top2f):
Top3f=choice_matrix[str(pred.Text[1])][pred.SVM_inception[1]]
else:
Top3f=Top2Text
else:
if(Top2SVM!=Top1f and Top2SVM!=Top2f):
Top3f=Top2SVM
else:
Top3f=choice_matrix[str(pred.Text[2])][pred.SVM_inception[2]]
else:
Top2f=choice_matrix[str(pred.Text[1])][pred.SVM_inception[1]]
if(pred.Text[1]!=pred.SVM_inception[1]):
if(Top2f!=classe[pred.Text[1]]):
Top3f=classe[pred.Text[1]]
else:
Top3f=classe[pred.SVM_inception[1]]
else:
Top3f=choice_matrix[str(pred.Text[2])][pred.SVM_inception[2]]
else:
Top1f=choice_matrix_img[str(pred.SVM_inception[0])][pred.inception[0]]
if(pred.SVM_inception[0]!=pred.inception[0]):
if(Top1f!=classe[pred.SVM_inception[0]]):
Top2f=classe[pred.SVM_inception[0]]
else:
Top2f=classe[pred.inception[0]]
Top2Inc=classe[pred.inception[1]]
Top2SVM=classe[pred.SVM_inception[1]]
if(Top2SVM!=Top1f and Top2SVM!=Top2f):
if(Top2Inc!=Top1f and Top2Inc!=Top2f):
Top3f=choice_matrix_img[str(pred.SVM_inception[1])][pred.inception[1]]
else:
Top3f=Top2SVM
else:
if(Top2Inc!=Top1f and Top2Inc!=Top2f):
Top3f=Top2Inc
else:
Top3f=choice_matrix_img[str(pred.SVM_inception[2])][pred.inception[2]]
else:
Top2f=choice_matrix[str(pred.SVM_inception[1])][pred.inception[1]]
if(pred.SVM_inception[1]!=pred.inception[1]):
if(Top2f!=classe[pred.SVM_inception[1]]):
Top3f=classe[pred.SVM_inception[1]]
else:
Top3f=classe[pred.inception[1]]
else:
Top3f=choice_matrix_img[str(pred.SVM_inception[2])][pred.inception[2]]
resultats["Best Predictions"][0]=Top1f
resultats["Best Predictions"][1]=Top2f
resultats["Best Predictions"][2]=Top3f
end = time.time()
print("Time taken: ",(end-start))
return resultats.to_html(justify='left', border = 0), text_detected
def preprocess_array(arr):
#version of preprocess_image, except for a numpy img_to_array
img = np.expand_dims(arr, axis=0)
img = inception_v3.preprocess_input(img)
return img
def load_image(image_path):
img = image.load_img(image_path, target_size=(128, 128))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
return x
def process(x):
return preprocess_input(x)
from keras.applications import inception_v3
from keras.preprocessing import image
import numpy as np
model = inception_v3.InceptionV3()
img = image.load_img("img/sigiriya/300px-Sigiriya.jpg", target_size=(299,299))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = inception_v3.preprocess_input(x)
pred = model.predict(x)
print(model.summary())
classes = inception_v3.decode_predictions(pred, top=5)
print(classes)
from keras.models import Model
from keras.callbacks import EarlyStopping, ModelCheckpoint
from keras.optimizers import adam, rmsprop, sgd
from keras.preprocessing.image import ImageDataGenerator
from keras.applications.inception_v3 import preprocess_input
from keras.datasets import cifar10
from keras.utils.np_utils import to_categorical
train = 'train/'
test = 'test/'
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
cifar_data = cifar10.load_data()
train_data = preprocess_input((cifar_data[0][0]).astype('float32'))
train_label = cifar_data[0][1]
test_data = preprocess_input((cifar_data[1][0]).astype('float32'))
test_label = cifar_data[1][1]
train_label = to_categorical(train_label, 10)
test_label = to_categorical(test_label, 10)
# Seting input size to 256x256 or else downstream features get too tiny for smaller images
def Resize(x):
y = tf.image.resize_bicubic(x, size=(256, 256))
return y
'''
def creat_model():
class LucidInceptionV3(Model):
# model_path = 'keras_inception_v3_frozen.pb.modelzoo'
model_path = args.modelzoo_file
image_shape = [299, 299, 3]
image_value_range = (0, 1)
input_name = 'input_1'
keras_model = InceptionV3(weights='imagenet', input_shape=(299, 299, 3))
inceptionv3 = LucidInceptionV3()
inceptionv3.load_graphdef()
# Image Processing
img_path = args.input_image_path
img = image.load_img(img_path, target_size=(299, 299))
x = image.img_to_array(img)
x = preprocess_input(x)
y = image.img_to_array(img)
y = np.expand_dims(y, axis=0)
y = preprocess_input(y)
layer_idx = args.conv_layer_idx
for i in range(len(keras_model.layers)):
if keras_model.layers[i].name == "conv2d_{}".format(layer_idx):
keras_layer_idx = i
break
layer_name = "conv2d_{}/convolution".format(layer_idx)
filter_idx = args.filter_idx
n_of_filter = args.num_of_filters
if filter_idx is None:
filters = [
from keras.models import load_model
model_mbn2 = load_model("models/t6_0.7002_1.0559_93_mbn2.model")
model_iv3_1 = load_model("models/t6_0.7396_0.9810_84_iv3.model")
model_iv3_2 = load_model("models/t6_0.7287_0.9836_59_iv3.model")
model_mbn2.name = 'model_mbn2'
model_iv3_1.name = 'model_iv3_1'
model_iv3_2.name = 'model_iv3_2'
models = [model_mbn2, model_iv3_1, model_iv3_2]
ensemble_model = ensemble(models, model_input)
ensemble_model.summary()
# In[ ]:
target_size = (299, 299)
yTest = np.zeros((len(xTest)))
for im in range(0, len(xTest)):
imR1 = cv2.resize(xTest[im],
dsize=target_size,
interpolation=cv2.INTER_NEAREST)
imR = np.expand_dims(imR1, axis=0)
#imR = np.expand_dims(xTest[im], axis=0)
imR = preprocess_input(imR.astype(np.float32))
yTest[im] = np.argmax(ensemble_model.predict(imR))
print("Finished image --- " + str(im) + "==" + str(yTest[im]))
df = pd.DataFrame(yTest)
df.to_csv("Task8/submission_t6_en.csv")
fid = ssdiff + trace(sigma1 + sigma2 - 2.0 * covmean)
return fid
# prepare the inception v3 model
model = InceptionV3(include_top=False,
pooling='avg',
input_shape=(299, 299, 3))
# define two fake collections of images
images1 = randint(0, 255, 1 * 32 * 32 * 3)
images1 = images1.reshape((1, 32, 32, 3))
images2 = randint(0, 255, 1 * 32 * 32 * 3)
images2 = images2.reshape((1, 32, 32, 3))
print('Prepared', images1.shape, images2.shape)
# convert integer to floating point values
images1 = images1.astype(np.uint8)
images2 = images2.astype(np.uint8)
# resize images
images1 = scale_images(images1, (299, 299, 3))
images2 = scale_images(images2, (299, 299, 3))
print('Scaled', images1.shape, images2.shape)
# pre-process images
images1 = preprocess_input(images1)
images2 = preprocess_input(images2)
# fid between images1 and images1
fid = calculate_fid(model, images1, images1)
print('FID (same): %.3f' % fid)
# fid between images1 and images2
fid = calculate_fid(model, images1, images2)
print('FID (different): %.3f' % fid)
# load our original input image
orig = cv2.imread(p)
# pre-process our image by converting it from BGR to RGB channel
# ordering (since our Keras mdoel was trained on RGB ordering),
# resize it to 64x64 pixels, and then scale the pixel intensities
# to the range [0, 1]
# order channel dimensions (channels-first or channels-last)
# depending on our Keras backend, then add a batch dimension to
# the image
image = load_img(p, target_size=(150, 150))
image = img_to_array(image) #output Numpy-array
image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2]))
image = preprocess_input(image)
x = model.predict(image)[0]
g = ("{:.1f}%".format(x[0] * 100))
label = "snake" if x[0] > .85 else "no snake"
color = (0, 0, 255) if x[0] < .85 else (0, 255, 0)
# resize our original input (so we can better visualize it) and
# then draw the label on the image
orig = cv2.resize(orig, (128, 128))
cv2.putText(orig, label, (3, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
cv2.putText(orig, g, (3, 35), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
# add the output image to our list of results
results.append(orig)
def _loadImageViaKeras(self, raw_uri):
uri = raw_uri[5:] if raw_uri.startswith("file:/") else raw_uri
image = img_to_array(load_img(uri))
image = np.expand_dims(image, axis=0)
return preprocess_input(image)
model = Model(inputs=base_model.input, outputs=predictions)
model.load_weights("Inceptionv3_2.h5")
#Performance Assesment :
import os
#For Clean Cars :
root_path = "../PICS/testnew/"
direc = "Clean/"
pred_sum = 0
for pic in os.listdir(root_path + direc):
img = image.load_img(root_path + direc + pic, target_size=(250, 400))
img = image.img_to_array(img)
img = np.expand_dims(img, axis=0)
img = preprocess_input(img)
preds = int(np.round(model.predict(img)))
pred_sum += preds
print("False Positive Rate :")
print(pred_sum / len(os.listdir(root_path + direc)))
#For Damaged Cars :
root_path = "../PICS/testnew/"
direc = "Damaged/"
pred_sum = 0
idx = 1
for pic in os.listdir(root_path + direc):
img = image.load_img(root_path + direc + pic, target_size=(250, 400))
img = image.img_to_array(img)
img = np.expand_dims(img, axis=0)
img = preprocess_input(img)
def video_summarizer(original_videos_folder,
trained_model="models_new/2_73.822.pth.tar"):
hps = HParameters()
ao = AONet(hps)
ao.initialize()
ao.load_model(trained_model)
model = InceptionV3(include_top=False,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling='avg',
classes=1000)
f = os.listdir(original_videos_folder)
f.sort()
f = ["videos/" + s for s in f if s[-1] == "4"]
#user_sumery_list=get_user_sumery_list()
#f=["20190425_165804.mp4"]
for ind_vid, vidio_path in enumerate(f):
cap = cv2.VideoCapture(vidio_path)
fps = int(cap.get(cv2.CAP_PROP_FPS))
length = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
frame = None
frames = []
for index in range(length):
ret, frame = cap.read()
try:
frame = cv2.resize(frame, (299, 299))
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
frames.append(frame)
except:
print(index)
print(vidio_path)
frames.append(frames[-1])
frames = np.array(frames)
frames = inception_v3.preprocess_input(frames)
predictions = model.predict(frames)
pred_sub_sump = predictions[np.arange(0, len(predictions), 15)]
seq = pred_sub_sump
seq = torch.from_numpy(seq).unsqueeze(0)
seq = seq.float().cuda()
#predict
y, att_vec = ao.model(seq, seq.shape[1])
cps = change_points(predictions, length, fps, vidio_path)
num_frames = length
positions = np.array(range(0, num_frames, 15), dtype=np.int64)
probs = y[0].detach().cpu().numpy()
#user_sumery=user_sumery_list[ind_vid]
# plt.title(vidio_path[7:-4])
# plt.bar(list(range(len(probs))), probs/np.sum(probs),alpha=0.4,color="r", linewidth=0.5)
# plt.bar(list(range(len(user_sumery))), user_sumery/np.sum(user_sumery),alpha=0.4,color="b", linewidth=0.5)
# plt.savefig(vidio_path[7:-4]+"plt"+"png")
# #plt.show()
nfps = [j - i + 1 for i, j in cps]
machine_summary = generate_summary(probs, cps, num_frames, nfps,
positions)
fourcc = cv2.VideoWriter_fourcc(*'XVID')
cap = cv2.VideoCapture(vidio_path)
out = cv2.VideoWriter(vidio_path[:-4] + ".avi", fourcc, fps,
(int(cap.get(3)), int(cap.get(4))))
for index in range(length):
ret, frame = cap.read()
if machine_summary[index] > 0.5:
out.write(frame)
# In[7]:
#from keras.applications.inception_v3 import InceptionV3, preprocess_input
from matplotlib.pyplot import imshow
import numpy as np
import glob
folder = './data/images/test/'
for gender in ['male','female']:
for img_path in glob.glob(folder + gender +'/*.jpg')[:30]:
#img_path = os.path.join('./data/images/test/', '/pic_153.jpg')
img = image.load_img(img_path, target_size=(299,299,3))
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)
pred_class = 'female' if preds.argmax()==0 else 'male'
if gender != pred_class:
print('Actual Class: %s , Pred class: %s , Scores: %s' % (gender,pred_class, str(preds)))
plt.imshow(img)
plt.show()
# In[8]:
def reverse_preprocessing(x):
x_reversed = x/2.
from keras.datasets import cifar10
from keras.applications.inception_v3 import InceptionV3, preprocess_input
from scipy.misc import imresize
from keras.utils import to_categorical
import numpy as np
#Data preprocessing
(X_train, Y_train), (X_test, Y_test) = cifar10.load_data()
X_train = np.array([imresize(x, (139, 139, 3))
for x in X_train[:10]]).astype('float32')
X_test = np.array([imresize(x, (139, 139, 3))
for x in X_test[:10]]).astype('float32')
X_train = preprocess_input(X_train)
X_test = preprocess_input(X_test)
Y_train = to_categorical(Y_train, num_classes=10)
Y_test = to_categorical(Y_test, num_classes=10)
#Importing Inception and extracting features
model = InceptionV3(include_top=False, input_shape=(139, 139, 3))
features_train = model.predict(X_train)
features_test = model.predict(X_test)
#saving features_to files
np.save('trainingfeatures', features_train)
np.save('testingfeatures', features_test)
np.save('traininglabels', Y_train)
np.save('testinglabels', Y_test)
X_val, y_val = np.load('../../data/train/X_val.npy'), np.load('../../data/train/y_val.npy')
y_tr = y_tr.astype(np.float32)
y_val = y_val.astype(np.float32)
print 'X_tr.shape:', X_tr.shape
print 'y_tr.shape:', y_tr.shape
print 'X_val.shape:', X_val.shape
print 'y_val.shape:', y_val.shape
# # Merge
# X = np.concatenate([X_tr, X_val], axis=0)
# y = np.array(list(y_tr) + list(y_val))
# y = y.astype(np.float32)
# print 'X.shape:', X.shape
# print 'y.shape:', y.shape
#
X_val = inception_v3.preprocess_input(X_val.astype(np.float16))
print 'Preprocess done. (Only Validation)'
# Preprocess func
def pre_func(im):
im = im.astype(np.float16)
im = im / 255.0
im = im - 0.5
im = im * 2.0
return im
##################################
# Constants
INPUT_SHAPE = (256, 256, 3)
model.set_weights(ws)
wp = np.copy(ws)
for index2, w in enumerate(ws):
shape = w.shape
if len(shape) == 4:
noise = np.random.normal(0, sigma,
(w.shape[0], w.shape[1],
w.shape[2], w.shape[3]))
wp[index2] = ws[index2] + noise
model.set_weights(wp)
for i in range(0, n_selected_batch):
images_path = os.path.join(
input_folder, 'x_val_' + str(i).zfill(3) + '.npy')
array = np.load(images_path)
X[i * samples_per_batch:(i + 1) *
samples_per_batch] = preprocess_input(array)
y_val_pred_p = model.predict(X, batch_size=64, verbose=1)
y_val_pred_ensemble[seed_index] = y_val_pred_p
nll_val = log_loss(y_val, y_val_pred_p)
print('sigma: {0:.6f}, seed: {1}, nll: val {2:.4f}'.format(
sigma, seed, nll_val))
y_val_pred_ensemble_mean = np.mean(y_val_pred_ensemble, axis=0)
nll = log_loss(y_val, y_val_pred_ensemble_mean)
nlls[sigma] = nll
nlls_log.append(
OrderedDict({
"iteration": iteration,
"sigma": sigma,
"nll": nll
}))
else:
def preprocess(self, inputImage):
# Keras expects RGB order
return inception_v3.preprocess_input(_reverseChannels(inputImage))
return
print "%s: %s" % (key, value)
i += 1
elephant_pic = 'elephant.jpg'
peacock_pic = 'peacock.jpg'
model = InceptionV3(weights='imagenet', include_top=True)
elephant_img = IMG.open(elephant_pic)
peacock_img = IMG.open(peacock_pic)
elephant = image.img_to_array(elephant_img)
peacock = image.img_to_array(peacock_img)
elephant = np.expand_dims(elephant, axis=0)
peacock = np.expand_dims(peacock, axis=0)
elephant = preprocess_input(elephant)
peacock = preprocess_input(peacock)
elephant_preds = model.predict(elephant)
peacock_preds = model.predict(peacock)
print("KERAS")
print('Elephant Probabilities:\n', decode_predictions(elephant_preds, top=3))
print('Peacock Probabilities:\n', decode_predictions(peacock_preds, top=3))
scale = 2./255
coreml_model = coremltools.converters.keras.convert(model,
input_names=['image'],
output_names=['probabilities'],
image_input_names='image',
image_batch = np.expand_dims(numpy_image, axis=0)
print('image batch size', image_batch.shape)
#vgg
processed_image = vgg16.preprocess_input(image_batch.copy())
predictions = vgg_model.predict(processed_image)
label = decode_predictions(predictions)
print("vgg", label)
#resnet
processed_image = resnet50.preprocess_input(image_batch.copy())
predictions = resnet_model.predict(processed_image)
label_resnet = decode_predictions(predictions, top=3)
print("resnet", label_resnet)
#mobileNet
processed_image = mobilenet.preprocess_input(image_batch.copy())
predictions = mobilenet_model.predict(processed_image)
label_mobilenet = decode_predictions(predictions)
print("mobilenet", label_mobilenet)
#inception_v3
#Has different input size
original = load_img(filename, target_size=(299, 299))
numpy_image = img_to_array(original)
image_batch = np.expand_dims(numpy_image, axis=0)
processed_image = inception_v3.preprocess_input(image_batch.copy())
predictions = inception_model.predict(processed_image)
label_inception = decode_predictions(predictions)
print("inception", label_inception)
def loadAndPreprocessKerasInceptionV3_save(uri):
# this is a typical way to load and prep images in keras
image = img_to_array(load_img(uri, target_size=(299, 299)))
image = np.expand_dims(image, axis=0)
return preprocess_input(image)
def predict(model, img):
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
preds = model.predict(x)
return preds[0]
'posts': jsonfile['numberPosts'],
'followers': jsonfile['numberFollowers'],
'following': jsonfile['numberFollowing'],
'images': []
}
# extract and compress images from the user's instagram page
for image in jsonfile['posts']:
if not image['isVideo']:
try:
# open image from URL and obtain compressed array representation for keras models
res = urllib.request.urlopen(image['urlImage'])
img = img_to_array(load_img(res, target_size=in_shape))
img = np.expand_dims(img_to_array(img), axis=0)
processed_img = preprocess_input(img)
# save images in image directory
savename = 'images/' + user_data[
'user'] + '_' + ''.join(
random.choices(
string.ascii_uppercase + string.digits,
k=15)) + '.jpg'
io.imsave(
savename,
np.reshape(img, (in_shape[0], in_shape[1], 3)))
# conduct image classification with Inception ResNet model
predictions = model.predict(processed_img)
predictions = imagenet_utils.decode_predictions(
predictions)
images_aug_tr, keypoints_aug_tr = SeqAug(images=X_train,
keypoints=y_train)
tar_train_reg, tar_train_cat = key2Target(
keypoints_aug_tr, name)
images_aug_te, keypoints_aug_te = SeqAugTest(images=X_test,
keypoints=y_test)
tar_test_reg, tar_test_cat = key2Target(keypoints_aug_te, name)
for ind, im in enumerate(images_aug_tr):
im = im[1000:1500, :, :] # Crop out only test area
#im = gaussBlur(im)
#im = gaborFilt(im)
#im = normalize(LOG(im,LOGker))
#im = enhanceImage(im)
if (useTransferLearning):
xx_tr.append(preprocess_input(im))
else:
#im = im/255.0
#im = np.array(im,dtype=np.float32)
yuv_im = im #cv2.cvtColor(im, cv2.COLOR_RGB2YCrCb)
xx_tr.append(yuv_im)
for ii in tar_train_reg:
yy_reg_tr.append(ii)
for ind, ii in enumerate(tar_train_cat):
if False: # Set to true to save train images augmentated
images_aug_tr[ind] = cv2.putText(
images_aug_tr[ind], str(tar_train_cat[ind]),
(0, 20), font, 0.5, (255, 0, 0), 2, cv2.LINE_AA)
images_aug_tr[ind] = cv2.circle(
images_aug_tr[ind],
(50, int(keypoints_aug_tr[ind][0][1])), 5,
def preprocess_image(image_path):
img = image.load_img(image_path)
img = image.img_to_array(img)
img = np.expand_dims(img, axis=0)
img = inception_v3.preprocess_input(img)
return img
def _loadImageViaKeras(self, raw_uri):
uri = raw_uri[5:] if raw_uri.startswith("file:/") else raw_uri
image = img_to_array(load_img(uri))
image = np.expand_dims(image, axis=0)
return preprocess_input(image)
cv_img = cv2.imread(img)
img_resize = cv2.resize(cv_img, (299, 299))
images.append(img_resize)
x = pd.DataFrame.from_dict(new_dict, orient='index').reset_index()
x.rename(columns={'index': 'image'}, inplace=True)
"""
Creating instance of a pretrained Inception V3 Convolutional Neural Network
to retrieve image features.
"""
model = InceptionV3(weights='imagenet', include_top=True)
model_new = Model(model.input, model.layers[-2].output)
image_dict = {}
for i in range(len(images)):
x = preprocess_input(images[i])
x = np.resize(x, (1, 299, 299, 3))
preds = model_new.predict(x)
preds = np.reshape(preds, preds.shape[1])
image_dict[image_names[i]] = preds
"""
Creating seperate dataframes for train, test and validation images
to create pickle files
"""
train_images = {}
test_images = {}
dev_images = {}
for i in range(len(train_df)):
if train_df.iloc[i][0] in image_dict.keys():
train_images[train_df.iloc[i][0]] = image_dict.get(train_df.iloc[i][0])
def pre_process(video_dir):
classes = []
X = []
y = []
all_videos_path = video_dir
if not os.path.exists('images'):
os.makedirs('images')
for fld in os.listdir(all_videos_path):
classes.append(fld)
for fld in os.listdir(all_videos_path):
for file in os.listdir(all_videos_path+fld):
video_path = str(all_videos_path+fld+'/'+file)
video_length = float(str(getLength(video_path)).split(",")[0].split(":")[-1])
if video_length < 1:
print("[WARN] Skipping video because of wrong length")
pass
else:
imagesFolder = "images"
cap = cv2.VideoCapture(video_path)
frameRate = cap.get(5)
count = 0
if video_length < 1.5:
controller = 4
elif video_length < 2.5:
controller = 6
elif video_length < 3.5:
controller = 8
elif video_length < 5.5:
controller = 10
elif video_length < 8.5:
controller = 12
else:
controller = 12
folder = '/tf/CNN_LSTM/images'
for the_file in os.listdir(folder):
file_path = os.path.join(folder, the_file)
try:
if os.path.isfile(file_path):
os.unlink(file_path)
except Exception as e:
print(e)
while(cap.isOpened()):
frameId = cap.get(1)
ret, frame = cap.read()
if (ret != True):
break
if (frameId%controller==0):
count = count + 1
filename = imagesFolder + "/image_" + str(int(count)) + ".jpg"
cv2.imwrite(filename, frame)
if frameId == controller*6:
break
cap.release()
print ("[INFO] Video Converted")
files = []
for f in os.listdir('images'):
if f.endswith(".jpg"):
files.append("images/"+str(f))
sequence = []
for f in files:
img = image.load_img(f, target_size=(299, 299))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
features = extactor_model.predict(x)
sequence.append(features)
label_encoded = classes.index(str(fld))
label_hot = to_categorical(label_encoded, len(classes))
X.append(sequence)
y.append(label_hot)
print("[INFO] Features Extracted for {} Frames at controller {} for class {}".format(len(sequence),controller,fld))
np.save("X_data",X)
np.save("y_data",y)
# 画像識別（inceptionV3）
from keras.preprocessing import image
from keras.applications.inception_v3 import preprocess_input, decode_predictions, InceptionV3
import numpy as np
# モデル読み込み（InceptionV3）
model = InceptionV3(weights='imagenet')
# 画像読み込み
img_path = 'test.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)
# 予測
preds = model.predict(x)
# 表示
for p in decode_predictions(preds, top=5)[0]:
print("Score {}, Label {}".format(p[2], p[1]))
def keras_load_and_preproc(fpath):
img = load_img(fpath, target_size=(299, 299))
img_arr = img_to_array(img)
img_iv3_input = iv3.preprocess_input(img_arr)
return np.expand_dims(img_iv3_input, axis=0)
def preprocess_input(x):
img = inception_v3.preprocess_input(image.img_to_array(x))
return image.array_to_img(img)
import os
import numpy as np
from keras.models import load_model
from keras.preprocessing.image import img_to_array, load_img
from keras.applications.inception_v3 import preprocess_input
model = load_model("hybrid.h5")
svmFit = load('hybrid_svmFit.joblib')
data = []
folderPath = "/Users/lvz/PycharmProjects/pothole_classifier/test"
for imageName in os.listdir(folderPath):
if imageName != ".DS_Store":
print("[INFO] classifying {}".format(imageName))
image = load_img(folderPath + "/" + imageName, target_size=(299, 299))
img_data = img_to_array(image)
img_data = np.expand_dims(img_data, axis=0)
# extract a color histogram feature from the image
img_data = preprocess_input(img_data)
feature = model.predict(img_data)
feature_np = np.array(feature)
data.append(feature_np.flatten())
else:
continue
labels = svmFit.predict(data)
print(labels)
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
})
