def compute_saliency(model,
guided_model,
img_path,
layer_name='block5_conv3',
cls=-1,
visualize=True,
save=True):
"""Compute saliency using all three approaches.
-layer_name: layer to compute gradients;
-cls: class number to localize (-1 for most probable class).
"""
preprocessed_input = load_image(img_path)
predictions = model.predict(preprocessed_input)
top_n = 5
top = decode_predictions(predictions, top=top_n)[0]
classes = np.argsort(predictions[0])[-top_n:][::-1]
print('Model prediction:')
for c, p in zip(classes, top):
print('\t{:15s}\t({})\twith probability {:.3f}'.format(p[1], c, p[2]))
if cls == -1:
cls = np.argmax(predictions)
class_name = decode_predictions(np.eye(1, 1000, cls))[0][0][1]
print("Explanation for '{}'".format(class_name))
gradcam = grad_cam(model, preprocessed_input, cls, layer_name)
gb = guided_backprop(guided_model, preprocessed_input, layer_name)
guided_gradcam = gb * gradcam[..., np.newaxis]
if save:
jetcam = cv2.applyColorMap(np.uint8(255 * gradcam), cv2.COLORMAP_JET)
jetcam = (np.float32(jetcam) +
load_image(img_path, preprocess=False)) / 2
cv2.imwrite('gradcam.jpg', np.uint8(jetcam))
cv2.imwrite('guided_backprop.jpg', deprocess_image(gb[0]))
cv2.imwrite('guided_gradcam.jpg', deprocess_image(guided_gradcam[0]))
if visualize:
plt.figure(figsize=(15, 10))
plt.subplot(131)
plt.title('GradCAM')
plt.axis('off')
plt.imshow(load_image(img_path, preprocess=False))
plt.imshow(gradcam, cmap='jet', alpha=0.5)
plt.subplot(132)
plt.title('Guided Backprop')
plt.axis('off')
plt.imshow(np.flip(deprocess_image(gb[0]), -1))
plt.subplot(133)
plt.title('Guided GradCAM')
plt.axis('off')
plt.imshow(np.flip(deprocess_image(guided_gradcam[0]), -1))
plt.show()
return gradcam, gb, guided_gradcam
def image_classification_server(img, model):
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
preds = model.predict(x)
# decode the results into a list of tuples (class, description, probability)
# (one such list for each sample in the batch)
print('*****Image classification result ****** \n{}'.format(
decode_predictions(preds, top=3)[0]))
# print(type(decode_predictions(preds, top=3)[0]))
return decode_predictions(preds, top=3)[0]
def image_classification(img_path):
#Don't create the model here ...Create it outside
model = VGG16(weights='imagenet', include_top=True)
img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
preds = model.predict(x)
# decode the results into a list of tuples (class, description, probability)
# (one such list for each sample in the batch)
print('*****Image classification result ****** \n{}'.format(
decode_predictions(preds, top=3)[0]))
# print(type(decode_predictions(preds, top=3)[0]))
return decode_predictions(preds, top=3)[0]
def main():
img = image.load_img(img_file, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
pre_x = preprocess_input(x)
model = VGG16(include_top=True, weights='imagenet', input_tensor=None, input_shape=None)
preds = model.predict(pre_x)
results = decode_predictions(preds, top=5)[0]
for result in results:
print(result)
# モデルの保存
model.summary()
with open('vgg16.json', 'w') as fp:
json_string = model.to_json()
fp.write(json_string)
# ディレクトリの作成
if not os.path.exists('output'):
os.mkdir("output")
# 出力するレイヤーを選択
for l in range(19):
layer_dump(model, pre_x, l)
print('finish.')
def run_model(img):
image = loadImage(img)
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)
# load the model
model = VGG16()
# predict the probability across all output classes
yhat = model.predict(image)
# convert the probabilities to class labels
label = decode_predictions(yhat)
# retrieve the most likely result, e.g. highest probability
label = label[0][0]
# print the classification
return (('%s (%.2f%%)' % (label[1], label[2] * 100)))
def grad_cam(input_model, image, category_index, layer_name):
model = Sequential()
model.add(input_model)
nb_classes = 1000
target_layer = lambda x: target_category_loss(x, category_index, nb_classes
)
model.add(
Lambda(target_layer, output_shape=target_category_loss_output_shape))
loss = K.sum(model.layers[-1].output)
conv_output = [l for l in model.layers[0].layers
if l.name is layer_name][0].output
grads = normalize(K.gradients(loss, conv_output)[0])
gradient_function = K.function([model.layers[0].input],
[conv_output, grads])
output, grads_val = gradient_function([image])
output, grads_val = output[0, :], grads_val[0, :, :, :]
weights = np.mean(grads_val, axis=(0, 1))
cam = np.ones(output.shape[0:2], dtype=np.float32)
for i, w in enumerate(weights):
cam += w * output[:, :, i]
cam = cv2.resize(cam, (224, 224))
cam = np.maximum(cam, 0)
heatmap = cam / np.max(cam)
#Return to BGR [0..255] from the preprocessed image
image = image[0, :]
image -= np.min(image)
image = np.minimum(image, 255)
cam = cv2.applyColorMap(np.uint8(255 * heatmap), cv2.COLORMAP_JET)
cam = np.float32(cam) + np.float32(image)
cam = 255 * cam / np.max(cam)
return np.uint8(cam), heatmap
preprocessed_input = load_image(sys.argv[1])
model = VGG16(weights='imagenet')
predictions = model.predict(preprocessed_input)
top_1 = decode_predictions(predictions)[0][0]
print('Predicted class:')
print('%s (%s) with probability %.2f' % (top_1[1], top_1[0], top_1[2]))
predicted_class = np.argmax(predictions)
cam, heatmap = grad_cam(model, preprocessed_input, predicted_class,
"block5_conv3")
cv2.imwrite("gradcam.jpg", cam)
register_gradient()
guided_model = modify_backprop(model, 'GuidedBackProp')
saliency_fn = compile_saliency_function(guided_model)
saliency = saliency_fn([preprocessed_input, 0])
gradcam = saliency[0] * heatmap[..., np.newaxis]
cv2.imwrite("guided_gradcam.jpg", deprocess_image(gradcam))
def Predict():
import __main__
ImageFile.LOAD_TRUNCATED_IMAGES = True
print("=== start predict ===")
predict = threading.current_thread()
model = VGG16(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None)
while getattr(predict, "decide", True):
filename = 'image.png'
img = __main__.image.load_img(filename, target_size=(224, 224))
image = __main__.image.img_to_array(img)
image = np.expand_dims(image, axis=0)
predict = model.predict(preprocess_input(image))
results = decode_predictions(predict, top=5)[0]
#picture = cv2.imread(filename)
for result in results:
print(result)
#cv2.imshow('test', picture)
#cv2.waitKey(1000)
#cv2.destroyAllWindows()
time.sleep(5)
def predict(filename, featuresize):
img = image.load_img(filename, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
preds = model.predict(preprocess_input(x))
results = decode_predictions(preds, top=featuresize)[0]
return results
def build_heat_map():
# k.clear_session()
model = VGG16(weights='imagenet')
img_tensor = get_image()
preds = model.predict(img_tensor)
print('Predicted: ', decode_predictions(preds, top=3)[0])
print(np.argmax(preds[0]))
african_elephant_output = model.output[:, 386]
last_conv_layer = model.get_layer('block5_conv3')
# tf.compat.v1.disable_eager_execution()
grads = k.gradients(african_elephant_output, last_conv_layer.output)[0]
pooled_grads = k.mean(grads, axis=(0, 1, 2))
iterate = k.function([model.input],
[pooled_grads, last_conv_layer.output[0]])
pooled_grads_value, conv_layer_output_value = iterate(img_tensor)
for i in range(512):
conv_layer_output_value[:, :, i] *= pooled_grads_value[i]
heatmap = np.mean(conv_layer_output_value, axis=-1)
heatmap = np.maximum(heatmap, 0)
heatmap /= np.max(heatmap)
plt.matshow(heatmap)
def upload_file():
response = {'success': False}
img_url = request.args.getlist('url')
response['list'] = []
for url in img_url:
responsePredict = {'url': url}
result = requests.get(url)
img = Image.open(BytesIO(result.content))
# img = Image.open(result.content)
if img.mode != 'RGB':
img = img.convert('RGB')
img = img.resize((224, 224))
img = image.img_to_array(img)
img = np.expand_dims(img, axis=0)
inputs = preprocess_input(img)
preds = model.predict(inputs)
results = decode_predictions(preds)
responsePredict['predictions'] = {
'label': results[0][0][1],
'probability': float(results[0][0][2])
}
response['list'].append(responsePredict)
response['success'] = True
return jsonify(response)
def classify_img_vgg(input_img_path):
sess = tf.Session()
model = VGG16()
print(model.summary())
# plot_model(model, to_file='vgg.png')
# load an imag from file
image = load_img(input_img_path, 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)
# retrieve the most likely result, e.g. highest probability
label = label[0][0]
# print the classification
print('%s (%.2f%%)' % (label[1], label[2]*100))
def predictIfFish(image, model):
# resize the image
dim = (224, 224)
resized = cv2.resize(image, dim, interpolation=cv2.INTER_LINEAR)
cv2_im = cv2.cvtColor(resized, cv2.COLOR_BGR2RGB)
pil_im = Image.fromarray(cv2_im)
image = image_utils.img_to_array(pil_im)
# 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)
# classify the image
#print("[INFO] classifying image...")
preds = model.predict(image)
decodedTups = decode_predictions(preds, top=5)[0]
FISH = ["SHARK", "HAMMERHEAD", "FISH"]
found = False
pr = 0.0
for tup in decodedTups:
for f in FISH:
if (f.upper() in tup[1].upper()):
#found = True
pr += tup[2]
#print ("found fish:" + tup[1] + ":pr=" + str(tup[2]))
#break
#if (found):
#break
if (pr > 0.25):
print("fish found:" + " tot pr=" + str(pr))
found = True
return found, pr
def predict(self, frame): img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB).astype(np.float32) img = img.reshape((1,) + img.shape) img = vgg16.preprocess_input(img) preds = self.model.predict(img) return vgg16.decode_predictions(preds)[0]
def pre_pic(img_path, topn=10):
if not path.isfile(img_path):
print("图片 pic 不存在")
# include_top=True，表示會載入完整的 VGG16 模型，包括加在最後3層的卷積層
# include_top=False，表示會載入 VGG16 的模型，不包括加在最後3層的卷積層，通常是取得 Features
# 若下載失敗，請先刪除 c:\<使用者>\.keras\models\vgg16_weights_tf_dim_ordering_tf_kernels.h5
model = VGG16(weights='imagenet', include_top=True)
# Input：要辨識的影像
#img_path = 'tiger.jpg' 并转化为224*224的标准尺寸
img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img) #转化为浮点型
x = np.expand_dims(x, axis=0) #转化为张量size为(1, 224, 224, 3)
x = preprocess_input(x)
# 預測，取得features，維度為 (1,1000)
features = model.predict(x)
# 取得前五個最可能的類別及機率
pred = decode_predictions(features, top=topn)[0]
return pred
def main(path):
strides = 2
batches = 1
#firstConv = load_model('first_conv.h5')
model_full = VGG16(weights='imagenet')
#print_summary(model_full, line_length=None, positions=None, print_fn=None)
#sys.exit(0)
#layer_name_conv1 = 'block1_conv1'
get_1st_layer_output = K.function([model_full.layers[0].input],
[model_full.layers[6].output])
get_final_layer_output = K.function([model_full.layers[7].input],
[model_full.layers[-1].output])
#firstConv_model = Model(inputs=model_full.input , outputs=model_full.get_layer(layer_name_conv1).output)
#model_part2 = load_model('ResNet50_NoConv1.h5')
#layer_name_conv2 = 'block1_conv2'
#layer_name_final = 'predictions'
#model_part2 = Model(inputs=model_full.get_layer(layer_name_conv2).input, outputs=model_full.get_layer(layer_name_final).output)
#layer_name = 'bn2a_branch1'
#intermediate_layer_model = Model(inputs=model_part2.input,
# outputs=model_part2.get_layer(layer_name).output)
#base = RN(weights='imagenet')
direc_path = path
i = 0
accuracy_list = []
for direc in os.listdir(direc_path):
#if i > 100: break
for img_name in os.listdir(direc_path + direc):
# pre-process each image and normalize before inference
inp_img = image.load_img(direc_path + direc + "/" + img_name,
target_size=(224, 224))
#inp_img = image.load_img(direc_path + direc + "/" + img_name, target_size=(299,299))
x = image.img_to_array(inp_img)
x = np.expand_dims(x, axis=0)
#x = randomize(x)
inputInit = preprocess_input(x.copy())
#inputInit = randomize(inputInit)
# Model part 1
start = time.time()
firstFeat = get_1st_layer_output([inputInit])[0]
firstFeat = np.float16(firstFeat)
newDataSet = (x, firstFeat)
if i and i % 10 == 0:
# #print(intermediateFeat.shape)
print(firstFeat.shape)
# print('intermediate conv takes', time.time() - start)
with open('perturbedData/%d.pickle' % i, 'wb') as handle:
pickle.dump(newDataSet, handle)
# Model part 3
start = time.time()
result2 = get_final_layer_output([firstFeat])[0]
predicted2 = decode_predictions(result2, top=3)[0]
accuracy_list.append(predicted2[0][0] == direc)
if i and i % 10 == 0:
compute_accuracy(accuracy_list)
print('remaining takes', time.time() - start)
i += 1
def predict():
img = None
img_path = ""
featuresize = 10
target = (224, 224)
data = {"success": False}
if 'size' in request.values:
featuresize = int(request.values['size'])
if 'img_path' in request.values:
img_path = request.values['img_path']
print('img_path=' + img_path)
img = get_image(img_path, target=target)
# process image
img = process_image(img)
# predict
with graph.as_default():
preds = model.predict(img)
results = decode_predictions(preds, top=featuresize)[0]
data["predictions"] = []
# loop over and format the result
for (imagenetID, label, prob) in results:
r = {
"label": label,
"probability": float(("{0:.2f}".format(prob * 100)))
}
data["predictions"].append(r)
data["success"] = True
return jsonify(data)
def process_image(img_path, idx=0):
img = image.load_img(img_path, target_size=(224, 224))
print('imageee')
print(image)
plt.imshow(img)
plt.grid(None)
plt.show()
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, top=3)[0])
class_index = np.argsort(preds[0])[-(1 + idx)]
class_output = model.output[:, class_index]
grads = K.gradients(class_output, last_conv_layer.output)[0]
pooled_grads = K.mean(grads, axis=(0, 1, 2))
iterate = K.function([model.input],
[pooled_grads, last_conv_layer.output[0]])
pooled_grads_value, conv_layer_output_value = iterate([x])
for i in range(512):
conv_layer_output_value[:, :, i] *= pooled_grads_value[i]
heatmap = np.mean(conv_layer_output_value, axis=-1)
heatmap = np.maximum(heatmap, 0)
heatmap /= np.max(heatmap)
plt.matshow(heatmap)
plt.grid(None)
plt.show()
show_superimposed_image(img_path, heatmap)
def predict(self, images, top=None):
if top is None:
top = self.num_classes
images = preprocess_input(images)
predictions = self.model.predict(images)
labels = decode_predictions(predictions, top=top)
return labels
def yomikomi(model, img):
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
preds = model.predict(preprocess_input(x))
#preds = model.predict(x)
results = decode_predictions(preds, top=1)[0]
return str(results[0][1])
def classifyFilesInFolder():
makeDir()
while (1 > 0):
listOfFiles = os.listdir(dirName)
if len(listOfFiles) != 0:
for filename in listOfFiles:
fileInDir = dirName + "/" + filename
if not os.path.isfile(fileInDir):
continue
reportDirFile = dirName + reportsDir + "/" + filename
image = load_img(fileInDir, target_size=(224, 224))
image = img_to_array(image)
image = image.reshape(
(1, image.shape[0], image.shape[1], image.shape[2]))
image = preprocess_input(image)
pred = model.predict(image, batch_size=16)
content = decode_predictions(pred, top=3)[0]
niz = []
for (i, (imagenetID, label, prob)) in enumerate(content):
niz.append(
("{}. {}: {:.2f}%".format(i + 1, label, prob * 100)))
niz.append(str(filename))
createTxtFile(reportDirFile, json.dumps(niz))
os.remove(fileInDir)
time.sleep(1)
def example03(img='../almacen/dog.jpg'):
from keras.preprocessing.image import load_img
from keras.preprocessing.image import img_to_array
from keras.applications.vgg16 import preprocess_input
from keras.applications.vgg16 import decode_predictions
from keras.applications.vgg16 import VGG16
print('Loading image: ' + img)
image = load_img(img, 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)
# load the model
print('Loading pre-trained model: VGG16')
model = VGG16()
# predict the probability across all output classes
yhat = model.predict(image)
# convert the probabilities to class labels
label = decode_predictions(yhat)
# retrieve the most likely result, e.g. highest probability
label = label[0][0]
# print the classification
print('%s (%.2f%%)' % (label[1], label[2] * 100))
def classification():
menu = {
'home': False,
'regression': False,
'senti': False,
'classification': True,
'clustering': False,
'member': False,
'creative': False
}
if request.method == 'GET':
return render_template('classification.html', menu=menu)
else:
f = request.files['image']
filename = os.path.join(app.root_path,
'static/images/uploads/') + secure_filename(
f.filename)
f.save(filename)
img = np.array(Image.open(filename).resize((224, 224)))
yhat = vgg.predict(img.reshape(-1, 224, 224, 3))
label_key = np.argmax(yhat)
label = decode_predictions(yhat)
label = label[0][0]
return render_template('cla_result.html',
menu=menu,
filename=secure_filename(f.filename),
label=label[1],
pct='%.2f' % (label[2] * 100))
def classification():
menu = {
'home': False,
'intro': False,
'rgrs': False,
'stmt': False,
'clsf': True,
'clst': False,
'user': False
}
if request.method == 'GET':
return render_template('classification.html', menu=menu)
else:
try:
f = request.files['image']
filename = os.path.join(app.root_path,
'static/images/uploads') + secure_filename(
f.filename)
f.save(filename)
img = np.array(Image.open(filename).resize((224, 224)))
yhat = vgg.predict(img.reshape(-1, 224, 224, 3))
label_key = np.argmax(yhat)
label = decode_predictions(yhat)
label = label[0][0]
except:
return render_template('classification.html', menu=menu)
return render_template('cla_result.html',
menu=menu,
filename=secure_filename(f.filename),
name=label[1],
pct='%.2f' % (label[2] * 100))
def features_cnn(X_CNN, CNN_PREDICTIONS, images_path, _dataImages):
model = VGG16(weights='imagenet', include_top=True)
start = time.time()
if len(CNN_PREDICTIONS) <= 0:
start_i = time.time()
img_list = process_images_keras(_dataImages, images_path)
end_i = time.time()
print("Processed Images finished: {}".format(end_i - start_i))
#model = ResNet50(weights='imagenet')
# Convert from list to ndarray
img_array_list = np.vstack(img_list)
# Feed all images to the model
print("No Cached Predictions")
CNN_PREDICTIONS = model.predict(img_array_list)
print("Finished dataset predictions")
else:
print("Using Cached Predictions")
end = time.time()
print("Model Predictions finished: {}".format(end - start))
#print("Resulting shape of the network output: {}".format(preds.shape))
concepts = decode_predictions(CNN_PREDICTIONS, top=5)
# Experiment with this parameter
k = 5
# Get the top K most probable concepts per image
sorted_concepts = np.argsort(CNN_PREDICTIONS, axis=1)[:, ::-1][:, :k]
data_tags = concepts
mlb = MultiLabelBinarizer(classes=range(0, 1000))
X_CNN = mlb.fit_transform(sorted_concepts)
# print(tags_bow.shape)
# model, concepts, mlb, tags_bow, predictions
return model, concepts, mlb, X_CNN, CNN_PREDICTIONS
def infer(self, data):
# if you need to get file uploaded, get the path from input_file_path in data
# load an image from file
image = load_img(data['input_file_path'], 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 = self.model.predict(image)
# convert the probabilities to class labels
label = decode_predictions(yhat)
# retrieve the most likely result, e.g. highest probability
label = label[0][0]
# print the classification
print('%s (%.2f%%)' % (label[1], label[2] * 100))
result = {"label": label[1], "confidence": label[2] * 100}
return result # return a dict
def run(self):
global graph, model
with graph.as_default():
image = load_img(self.path, target_size=(224, 224))
image = img_to_array(image)
image = image.reshape(
(1, image.shape[0], image.shape[1], image.shape[2]))
image = preprocess_input(image)
pred = model.predict(image)
label = decode_predictions(pred)
#print(label)
label = label[0][0]
self.myapp.Display_Title(label[1])
#print('%s (%.2f%%)' % (label[1], label[2]*100))
wiki_content = ''
try:
info_page = wiki.page(label[1])
img_content = info_page.content
#print('------Wiki------')
#print(img_content[:200]+'....')
wiki_content = img_content[:350] + '....'
except:
tb = traceback.format_exc()
print(tb)
s_result = ''
#print('------Related----------')
s = search(label[1], num=3, stop=1)
for j in s:
s_result = s_result + j + "\n"
info = [label[1], wiki_content, s_result]
self.myapp.Display(info)
playsound(label[1] + ".mp3")
def infer(self, img_filename):
image = self.input_preprocess(img_filename)
yhat = self.model.predict(image)
label = decode_predictions(yhat)
label = label[0][0]
print('%s (%.2f%%)' % (label[1], label[2] * 100))
def main():
if len(sys.argv) != 2:
print('以下のように入力してください')
print('python simple_vgg16_usage.py [image file path]')
sys.exit(1)
file_name = sys.argv[1]
# 学習済みのVGG16(学習済みの重みも含める)をロード
model = VGG16(weights='imagenet')
model.summary()
# 画像ファイルの読み込み(サイズを224 * 224にリサイズ)
img = image.load_img(file_name, target_size=(224, 224))
# 読み込んだPIL形式の画像をarrayに変換
x = image.img_to_array(img)
# 3次元テンソル（rows, cols, channels) を
# 4次元テンソル (samples, rows, cols, channels) に変換
# 入力画像は1枚なのでsamples=1でよい
x = np.expand_dims(x, axis=0)
preds = model.predict(preprocess_input(x))
results = decode_predictions(preds, top=5)[0]
for result in results:
print(result)
cam = Grad_Cam(model, x[0], 'block5_conv3')
img = array_to_img(cam)
img.save('cam.jpg')
def predict():
print('model predict is called. ', file=sys.stderr)
#create instance of VGG16 model
model = VGG16()
# read client request
message = request.get_json(force=True)
encoded = message['image']
decoded = base64.b64decode(encoded)
image = Image.open(io.BytesIO(decoded))
image = preprocessImage(image, target_size=(224, 224))
#print(image.shape , file=sys.stderr)
# predict the probability across all output classes
yhat = model.predict(image)
# convert the probabilities to class labels
label1 = decode_predictions(yhat)
# retrieve the most likely result, e.g. highest probability
label = label1[0][0]
objName = label[1]
objConfidence = label[2] * 100
# print the classification
#print('%s (%.2f%%)' % (label[1], label[2]*100), file=sys.stderr)
#prepare return response
response = {'prediction': {'name': objName, 'confidence': objConfidence}}
# clear this session before returning to client
keras.backend.clear_session()
return jsonify(response)
def item_detection(img_file):
# <tensor> is not an element of this graph error に対処
global graph
with graph.as_default():
model = VGG16(include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None)
img = image.load_img(img_file, target_size=(224, 224))
x = image.img_to_array(img)
# 3次元テンソル（rows, cols, channels) を
# 4次元テンソル (samples, rows, cols, channels) に変換
# 入力画像は1枚なのでsamples=1でよい
x = np.expand_dims(x, axis=0)
# VGG16の1000クラスはdecode_predictions()で文字列に変換される
# preprocess_inputでVGG16の平均を引く前処理を行う
preds = model.predict(preprocess_input(x))
results = decode_predictions(preds, top=5)[0]
return results[0][1], results[0][2]
def image_to_objects(img_path):
model = VGG16(weights='imagenet')
img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
preds = model.predict(x)
return [label[1] for label in decode_predictions(preds, top=3)[0]]
import numpy as np
import matplotlib.pyplot as plt
import cv2
from utils import init_keras
init_keras()
img_path = r"C:\Users\huxiaomi\Downloads\deep-learning\data\kaggle-dogs-vs-cats\small\test\cats\cat.1502.jpg"
img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
model = VGG16(weights='imagenet')
preds = model.predict(x)
print('Predicted:', decode_predictions(preds, top=3)[0])
idx_of_max = np.argmax(preds[0])
hit_output = model.output[:, idx_of_max]
last_conv_layer = model.get_layer('block5_conv3')
grads = K.gradients(hit_output, last_conv_layer.output)[0]
pooled_grads = K.mean(grads, axis=(0, 1, 2))
iterate = K.function([model.input], [pooled_grads, last_conv_layer.output[0]])
pooled_grads_value, last_conv_layer_output_value = iterate([x])
for i in range(512):
last_conv_layer_output_value[:, :, i] *= pooled_grads_value[i]
from keras.preprocessing.image import load_img, img_to_array
import numpy as np
model = VGG16()
dog = load_img('imgs/dog.jpg', target_size=(224, 224))
dog = img_to_array(dog)
cat = load_img('imgs/cat.jpg', target_size=(224, 224))
cat = img_to_array(cat)
goma = load_img('imgs/goma.jpeg', target_size=(224, 224))
goma = img_to_array(goma)
# convert RGB2BGR and centerize
dog = preprocess_input(dog)
cat = preprocess_input(cat)
goma = preprocess_input(goma)
input_array = np.stack([dog, cat, goma])
probs = model.predict(input_array)
results = decode_predictions(probs)
assume_dog = results[0]
assume_cat = results[1]
assume_goma = results[2]
print(assume_dog)
print(assume_cat)
print(assume_goma)