def classify_image(image_arg):
print("[INFO] loading and preprocessing image...")
image = image_utils.load_img(image_arg, target_size=(224, 224))
image = image_utils.img_to_array(image)
# our image is now represented by a NumPy array of shape (3, 224, 224),
# but we need to expand the dimensions to be (1, 3, 224, 224) so we can
# pass it through the network -- we'll also preprocess the image by
# subtracting the mean RGB pixel intensity from the ImageNet dataset
image = np.expand_dims(image, axis=0)
image = preprocess_input(image)
# load the VGG16 network
# print("[INFO] loading network...")
# classify the image
# print("[INFO] classifying image...")
preds = model.predict(image,32,1)
preds=preds.reshape(1000)
#(inID, label) = decode_predictions(preds)[0]
top_pred,out_label_probs = decode_predictions(preds)
# print "Top predictions : "
# print "Label : {}, Probability: {}".format(top_pred['label'],top_pred['prob'])
# print "Top labels with proobabilites : "
# for label in out_label_probs:
# print "Label : {}, Probability: {}".format(label['label'],label['prob'])
return top_pred, out_label_probs
def predictor(self, sys):
try:
if len(sys.argv) < 2:
print("Usage : ./saying-object.py <image path>")
sys.exit()
img_path = sys.argv[1]
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)
objek = "?"
preds = model.predict(x)
pred_dict = decode_predictions(preds)
objek = pred_dict[0][0][1]
if len(objek) > 1:
words = "Your object detected as " + objek.replace("_", " ")
self.tts_online_gtts_speak(words)
else:
words = "sorry sir failed to predict your image"
self.tts_online_gtts_speak(words)
except:
raise
def predict(self, frame):
image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB).astype(np.float32)
image = image.transpose((2, 0, 1))
image = image.reshape((1, ) + image.shape)
image = preprocess_input(image)
preds = self.model.predict(image)
return decode_predictions(preds)[0]
def predict(self, frame):
image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB).astype(np.float32)
image = np.expand_dims(image, axis=0)
image = preprocess_input(image)
preds = self.model.predict(image)
label = decode_predictions(preds)[0][0][0:2]
#self.write_arduino(label)
return label
def classify_image(img_path):
#model = ResNet50(weights='imagenet')
#img_path = '1360x.jpeg'
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)
print('Predicted:', decode_predictions(preds))
def Generate_scores(img):
print("[INFO] loading and preprocessing image...")
image = image_utils.load_img(img, target_size=(224, 224))
image = image_utils.img_to_array(image)
image = np.expand_dims(image, axis=0)
image = preprocess_input(image)
print("[INFO] loading network...")
model = VGG16(weights="imagenet")
print("[INFO] classifying image...")
preds = model.predict(image)
(__, inID, label) = decode_predictions(preds)[0][0]
result = decode_predictions(preds, top=10)[0]
display(Image(img))
result_frame = pd.DataFrame(result).ix[:, 1:]
result_frame.columns = ["item", "probability"]
result_frame.index = result_frame.index + 1
#display(result_frame)
import seaborn as sns
import matplotlib.pyplot as plt
get_ipython().run_line_magic('matplotlib', 'inline')
plt.figure(figsize=(10, 7))
sns.set_style('white')
sns.set_context('talk', font_scale=1.8)
sns.set_color_codes("pastel")
ax = sns.barplot(x='probability',
y='item',
data=result_frame,
color="b",
palette="Blues_r")
sns.plt.title('What is it?')
ax.set(xlim=(0, 1))
ax.set(xlabel='Probability', ylabel='Object')
def get_prediction(input_path):
input_img = load_img(input_path, single_input_shape, grayscale)
with get_evaluation_context():
return jsonify(
json.loads(
get_json(
decode_predictions(
model.predict(input_img)
)
)
)
)
def recognize(path): global model img = image.load_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) decoded = decode_predictions(preds, 3) result = [(x[1],float(x[2])) for x in decoded[0]] return(result)
def predict(filename):
assert os.path.isfile(filename) and 'cannot find file'
model = ResNet50(weights='imagenet')
img = image.load_img(filename, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
preds = decode_predictions(model.predict(x))
if len(preds) == 0:
return None
return preds[0][0][1]
def Generate_scores(img):
print("[INFO] loading and preprocessing image...")
image = image_utils.load_img(img, target_size=(224, 224))
image = image_utils.img_to_array(image)
image = np.expand_dims(image, axis=0)
image = preprocess_input(image)
print("[INFO] loading network...")
model = VGG16(weights="imagenet")
print("[INFO] classifying image...")
preds = model.predict(image)
(__, inID, label) = decode_predictions(preds)[0][0]
result=decode_predictions(preds, top=10)[0]
display(Image(img))
result_frame=pd.DataFrame(result).ix[:,1:]
result_frame.columns=["item", "probability"]
result_frame.index=result_frame.index +1
#display(result_frame)
import seaborn as sns
import matplotlib.pyplot as plt
get_ipython().run_line_magic('matplotlib', 'inline')
plt.figure(figsize=(10,7))
sns.set_style('white')
sns.set_context('talk',font_scale=1.8)
sns.set_color_codes("pastel")
ax=sns.barplot(x='probability',y='item',data=result_frame,color="b", palette="Blues_r")
sns.plt.title('What is it?')
ax.set(xlim=(0, 1))
ax.set(xlabel='Probability', ylabel='Object')
def callback(data):
if prev == data:
return
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)
# print('start')
preds = model.predict(x)
print('Predicted:', decode_predictions(preds))
prev = data
def eval(paths=['cat.jpg']):
model = VGG19(include_top=True, weights='imagenet')
imgs = [
image.load_img(img_path, target_size=(224, 224)) for img_path in paths
]
preds = []
for img in imgs:
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
print('Input image shape:', x.shape)
preds.extend(decode_predictions(model.predict(x)))
return preds
def accuracy(Y_true, Y_pred):
val_labels_fnames = \
'/lfs/1/ddkang/specializer/imagenet/ILSVRC2012_devkit_t12/data/val_gt_wnid.txt'
df_labels = pd.read_csv(val_labels_fnames, names=['wnid'])
Y_true = df_labels.values
Y_true = map(lambda x: x[0], Y_true)
Y_pred_dec = imagenet_utils.decode_predictions(Y_pred)
acc = 0.0
t5 = 0.0
for i in xrange(len(Y_true)):
s = set(map(lambda x: x[0], Y_pred_dec[i]))
if Y_true[i] == Y_pred_dec[i][0][0]:
acc += 1
if Y_true[i] in s:
t5 += 1
acc /= len(Y_true)
t5 /= len(Y_true)
print '%f,%f' % (acc, t5)
def predictOutput(self):
orig = cv2.imread(self.imageName)
# classify the image
print("[INFO] classifying image...")
preds = self.model.predict(self.image)
preds_class = self.model.predict_classes(self.image)
#top4class_index = [i for i in np.argsort(preds[0])[-4:]]
#top4class_prob = [preds[0][i] for i in np.argsort(preds[0])[-4:]]
#print top4class_index
#print top4class_prob
preds_prob = preds[0][preds_class]
(inID, label) = decode_predictions(preds)[0]
# display the predictions to our screen
output_text = ('Class Label :{}'.format(preds_class) + '\n' +
'class Prob : {}'.format(preds_prob) + '\n' +
'Class Name : {}'.format(label) + '\n' +
'Imagenet Id : {}'.format(inID))
self.console_output.setText(output_text)
print("ImageNet ID: {}, Label: {}".format(inID, label))
def predict(path, model_path, index_file_path, MainUI):
try:
result_string = " Detected Object : Probability \n \n"
# Making check to load Model
if (MainUI.resnet_model_loaded == False):
wx.CallAfter(pub.sendMessage, "report101", message="Loading ResNet model for the first time. This may take a few minutes or less than a minute. Please wait. \nLoading.....")
model = ResNet50(include_top=True, weights="imagenet", model_path=model_path)
wx.CallAfter(pub.sendMessage, "report101", message="ResNet model loaded.. Picture about to be processed.. \nLoading......")
MainUI.model_collection_resnet.append(model) # Loading model if not loaded yet
MainUI.resnet_model_loaded = True
else:
wx.CallAfter(pub.sendMessage, "report101", message="Retrieving loaded model. \nLoading........")
model = MainUI.model_collection_resnet[0] # Getting Model from model array if loaded before
wx.CallAfter(pub.sendMessage, "report101", message="ResNet model loaded.. Picture about to be processed.. \nLoading......")
# Image prediction processing
target_image = image.load_img(path, grayscale=False, target_size=(224, 224))
target_image = image.img_to_array(target_image, data_format="channels_last")
target_image = np.expand_dims(target_image, axis=0)
target_image = preprocess_input(target_image, data_format="channels_last")
wx.CallAfter(pub.sendMessage, "report101", message="Picture is transformed for prediction. \nLoading........")
prediction = model.predict(x=target_image, steps=1)
wx.CallAfter(pub.sendMessage, "report101", message="Picture prediction is done. Sending in results. \nLoading......")
# Retrieving prediction result and sending it back to the thread
prediction_result = decode_predictions(prediction, top=10, index_file_path=index_file_path)
for results in prediction_result:
countdown = 0
for result in results:
countdown += 1
result_string += "(" + str(countdown) + ") " + str(result[1]) + " : " + str(100 * result[2])[
0:4] + "% \n"
return result_string
except Exception as e:
return getattr(e, "message", repr(e))
def predict_image(image_name):
image_path = os.path.join(os.getcwd(), 'images', image_name)
print("[INFO] loading and preprocessing image...")
image = image_utils.load_img(image_path, target_size=(224, 224))
image = image_utils.img_to_array(image)
image = np.expand_dims(image, axis=0)
image = preprocess_input(image)
print(image.shape)
# load the VGG16 network
print("[INFO] loading network...")
model = VGG16(weights="imagenet")
# classify the image
print("[INFO] classifying image...")
preds = model.predict(image)
#report = decode_predictions(preds)
#print(report)
(inID, label, probability) = decode_predictions(preds)[0][0]
# display the predictions to our screen
print("ImageNet ID: {}, Label: {}".format(inID, label))
return label
from __future__ import print_function
from keras.datasets import cifar10
from keras.utils import np_utils
from keras.preprocessing import image
from imagenet_utils import decode_predictions, preprocess_input
from VideoDebugger import imshow
from vgg16 import VGG16
import cv2
import numpy as np
(X_train, y_train), (X_test, y_test) = cifar10.load_data()
print('X_train shape:', X_train.shape)
print(X_train.shape[0], 'train samples')
print(X_test.shape[0], 'test samples')
model = VGG16(include_top=True,
weights='vgg16_weights_tf_dim_ordering_tf_kernels.h5')
for img in X_test:
img = cv2.resize(img, (224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
preds = decode_predictions(model.predict(x))
print(preds)
cv2.putText(img, preds[0][0][1], (10, 200), cv2.FONT_HERSHEY_SIMPLEX, 1,
(255, 255, 255), 2)
imshow(img)
# NumPy array
print("[INFO] loading and preprocessing image...")
image = image_utils.load_img(args["image"], target_size=(224, 224))
image = image_utils.img_to_array(image)
# our image is now represented by a NumPy array of shape (3, 224, 224),
# but we need to expand the dimensions to be (1, 3, 224, 224) so we can
# pass it through the network -- we'll also preprocess the image by
# subtracting the mean RGB pixel intensity from the ImageNet dataset
image = np.expand_dims(image, axis=0)
image = preprocess_input(image)
# load the VGG16 network
print("[INFO] loading network...")
model = VGG16(weights="imagenet")
print(model.summary())
# classify the image
print("[INFO] classifying image...")
preds = model.predict(image)
P = decode_predictions(preds)
(imagenetID, label, prob) = P[0][0]
print(P)
# display the predictions to our screen
print("ImageNet ID: {}, Label: {}".format(imagenetID, label))
cv2.putText(orig, "Label: {}".format(label), (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
cv2.imshow("Classification", orig)
cv2.waitKey(0)
while True:
if predict_now:
vid = imageio.get_reader(filename, 'ffmpeg')
for i, im in enumerate(vid):
print('Frame #:', i)
rows, cols, channels = im.shape
im = im[:, cols // 2 - rows // 2:cols // 2 +
rows // 2, :] # crop image so that cols = rows)
im = resize(
im, (224, 224)) # resize to 224 x 224, the network input size
x = image.img_to_array(im)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
#print('Input image shape:', x.shape)
preds = model.predict(x)
decoded = decode_predictions(preds)[0]
predList = [x[0] for x in decoded]
nameList = [x[1] for x in decoded]
probList = [x[2] for x in decoded]
detectedList = [
[nameList[jj], probList[jj]] for jj in range(len(predList))
if predList[jj] in vWordList and probList[jj] > 0.09
]
#print(nameList)
if len(detectedList) > 0:
print('VEHICLE PRESENT')
#print(detectedList)
predict_now = False
if doexit:
print('Exiting...')
# get all available images
img_names_on_disk = os.listdir(path_images)
img_paths_on_disk = [path_images + x for x in img_names_on_disk]
# loop through all images, make a classification and plot
for img_path in img_paths_on_disk:
img_name = img_path.split("/")[-1]
# img = image.load_img(img_path, target_size=(224, 224))
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)
preds_dec = decode_predictions(preds)
print('Predicted:', preds_dec)
# save predictions in data frame
pred_labels = [x[1] for x in preds_dec[0]]
pred_scores = [x[2] for x in preds_dec[0]]
preds_df = pd.DataFrame({'Species' : pred_labels, 'Score': pred_scores})
plot_pred_vs_image(img,preds_df,path + 'models/IncepV3_' + img_name.strip('.JPG'))
preds = model.predict(x)
# Quantization of the model
if nb_images == 0: # Do it only once.
nb_wq = [7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,3,3,3,3] # each element of the vector quantizes 1 layer.
nb_iq = 6
qsf = 0 # Quantize Starting From layer number qsf
all_weights_bu = back_up()
non_zero = cnz(all_weights_bu)
print('Number of MBytes used by weights : ', non_zero*32/float(8*1024**2))
modelq = model
all_weightsq = q_weights(nb_wq,all_weights_bu, qsf)
xq = q_inputs(x, nb_iq)
non_zeroq = cntz_bits(all_weightsq, nb_wq)
print('Memory MBytes used by weights : ', non_zeroq/float(8*1024**2))
predsq = modelq.predict(x)
print('NON Q predicted : ', decode_predictions(preds))
print(' Q predicted : ', decode_predictions(predsq))
result += evaluate_q(preds, predsq)
# Number of images evaluated
nb_images += 1
print('Number of images evaluated : ', nb_images)
print('Percentage of matches : ', result/float(nb_images))
os.chdir("../.")
# Load the VGG16 network
print("[INFO] loading network...")
model = VGG16(weights="imagenet")
for file in files:
# Load the image using OpenCV
orig = cv2.imread(file)
# Load the image using Keras helper ultility
print("[INFO] loading and preprocessing image...")
image = image_utils.load_img(file, target_size=(224, 224))
image = image_utils.img_to_array(image)
# Convert (3, 224, 224) to (1, 3, 224, 224)
# Here "1" is the number of images passed to network
# We need it for passing batch containing serveral images in real project
image = np.expand_dims(image, axis=0)
image = preprocess_input(image)
# Classify the image
print("[INFO] classifying image...")
preds = model.predict(image)
(inID, label) = decode_predictions(preds)[0]
# Display the predictions
print("ImageNet ID: {}, Label: {}".format(inID, label))
cv2.putText(orig, "Label: {}".format(label), (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
cv2.imshow("Classification", orig)
cv2.waitKey(0)
# load the ResNet50 network
print("[INFO] loading network...")
model = ResNet50(weights="imagenet")
# classify the image
print("[INFO] classifying image...")
# get the symbolic outputs of each "key" layer (we gave them unique names).
layer_outputs = [layer.output for layer in model.layers]
viz_model = Model(input=model.input, output=layer_outputs)
preds = model.predict(image)
features = viz_model.predict(image)
pool = features[174]
P = decode_predictions(preds, top=10)
(imagenetID, label1, prob) = P[0][0]
#writing embeddings to TSV file
print(pool.shape)
with open("globel_pool.tsv", "w") as fp:
fp.write("#\tFeatures (Channels)\n")
for (i, val) in enumerate(pool[0][0][0]):
fp.write(str(i + 1))
fp.write("\t")
fp.write(str(val))
fp.write("\n")
fp.close()
# loop over the predictions and display the rank-5 predictions +
#yeni ağı yeniden eğitebilmek için tüm katmanların eğitim moduna getiriyoruz
for layer in custom_resnet_model.layers[:-1]:
layer.trainable = False
custom_resnet_model.layers[-1].trainable
custom_resnet_model.compile(loss='categorical_crossentropy',optimizer='adam',metrics=['accuracy'])
#eğitim
t=time.time()
hist = custom_resnet_model.fit(X_train, y_train, batch_size=32, epochs=1, verbose=1, validation_data=(X_test, y_test))
print('eğitim süresi: %s' % (time.time()-t))
(loss, accuracy) = custom_resnet_model.evaluate(X_test, y_test, batch_size=10, verbose=1)
print("loss={:.4f}, accuracy: {:.4f}%".format(loss,accuracy * 100))
#### test
img_path = 'kedi.jpg'
img = image.load_img(img_path, target_size=(224, 224))
test_img = image.img_to_array(img)
test_img = np.expand_dims(test_img, axis=0)
test_img = preprocess_input(test_img)
preds = model.predict(test_img)
print('Tahmin:', decode_predictions(preds))
# our image is now represented by a NumPy array of shape (3, 224, 224),
# but we need to expand the dimensions to be (1, 3, 224, 224) so we can
# pass it through the network -- we'll also preprocess the image by
# subtracting the mean RGB pixel intensity from the ImageNet dataset
image = np.expand_dims(image, axis=0)
image = preprocess_input(image)
# load the VGG16 network
print("[INFO] loading network...")
model = VGG16(weights="imagenet")
# classify the image
print("[INFO] classifying image...")
preds = model.predict(image)
result = decode_predictions(preds, top=1)
(inID, label, val) = decode_predictions(preds)[0][0]
print(result[0])
print(len(result))
#result1 = ([col.strip() for col in part] for part in result)
#print(result1)
#print(decode_predictions(preds)[0])
# display the predictions to our screen
print("ImageNet ID: {}, Label: {}".format(inID, label))
cv2.putText(orig, "Label: {}".format(label), (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
plt.ioff()
plt.imshow(orig)
success,frame = vidcap.read()
frame_count = 0
model,preprocess_mode = load_model(args)
prediction_dict = {}
while success:
img = load_image(frame,args.model)
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x,mode=preprocess_mode)
preds = model.predict(x)
prediction = decode_predictions(preds, 3)
vidcap.set(1,frame_count)
success,frame = vidcap.read()
frame_count += offset
#Print frame prediction
print ("Frame : %d -> \t %s , \t %s , \t %s" % (frame_count,prediction[0][0][1],prediction[0][1][1],prediction[0][2][1]))
#Make a dictionary with probs
for i in range(0,3):
if str(prediction[0][i][1]) in prediction_dict :
prediction_dict[str(prediction[0][i][1])]+=prediction[0][i][2]
else :
prediction_dict[str(prediction[0][i][1])]=prediction[0][i][2]
def predict(path, model_path, index_file_path, MainUI):
try:
result_string = " Detected Object : Probability \n \n"
if (MainUI.squeezenet_model_loaded == False):
wx.CallAfter(
pub.sendMessage,
"report101",
message=
"Loading SqueezeNet model for the first time. This may take few minutes or less than a minute. Please wait. \nLoading....."
)
model = SqueezeNet(model_path=model_path)
wx.CallAfter(
pub.sendMessage,
"report101",
message=
"SqueezeNet model loaded.. Picture about to be processed.. \nLoading......"
)
MainUI.model_collection_squeezenet.append(model)
MainUI.squeezenet_model_loaded = True
else:
wx.CallAfter(pub.sendMessage,
"report101",
message="Retrieving loaded model. \nLoading........")
model = MainUI.model_collection_squeezenet[0]
wx.CallAfter(
pub.sendMessage,
"report101",
message=
"ResNet model loaded.. Picture about to be processed.. \nLoading......"
)
img = image.load_img(path, target_size=(227, 227))
img = image.img_to_array(img, data_format="channels_last")
img = np.expand_dims(img, axis=0)
img = preprocess_input(img, data_format="channels_last")
wx.CallAfter(
pub.sendMessage,
"report101",
message="Picture is transformed for prediction. \nLoading........")
prediction = model.predict(img, steps=1)
wx.CallAfter(
pub.sendMessage,
"report101",
message=
"Picture prediction is done. Sending in results. \nLoading......")
predictiondata = decode_predictions(prediction,
top=10,
index_file_path=index_file_path)
for results in predictiondata:
countdown = 0
for result in results:
countdown += 1
result_string += "(" + str(countdown) + ") " + str(
result[1]) + " : " + str(100 * result[2])[0:4] + "% \n"
return result_string
except Exception as e:
return getattr(e, "message", repr(e))
if __name__ == '__main__':
model = InceptionV3(include_top=True, weights='imagenet')
cam = cv2.VideoCapture(0)
while (True):
ret, frame = cam.read()
cv2.imwrite("output.png", frame)
img_path = "output.png"
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)
recognize = decode_predictions(preds)
print('Label:', recognize[0][0][1])
cv2.putText(frame, "Label: {}".format(recognize), (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
cv2.imshow("Show FLAME Image", frame)
k = cv2.waitKey(1)
if k == ord('q'):
break
cam.release()
cv2.destroyAllWindows()
def proc(taskFile, rootDir, atOnce=10000):
good = list()
bad = list()
ugly = list()
interesting = set()
count = 0
im = 0
model = ResNet50(weights='imagenet')
for x in [
'car', 'pickup', 'suv', 'truck', 'crossover', 'van', 'minivan',
'sports_car', 'cab', 'racer', 'convertible', 'jeep', 'ambulance'
]:
interesting.add(x)
data = readTasking(taskFile)
startTime = time.time()
for d in data:
img_path = '{0}/{1}'.format(rootDir, d['filename'])
flag = True
try:
img = image.load_img(img_path, target_size=(224, 224))
except:
# ugly this is not a decodable image
ugly.append(d)
flag = False
if flag:
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
preds = model.predict(x)
predictions = decode_predictions(preds)[0][:4]
found = False
for prediction in predictions:
i, t, score = prediction
if t in interesting:
# image was interesting
good.append((d, t))
found = True
break
if not found:
# image was not interesting
bad.append((d, predictions[0][1]))
if count == atOnce:
count = 0
endTime = time.time() - startTime
im = im + 1
print('processed:', im * atOnce, 'Images', 'good', len(good),
'bad', len(bad), 'file', len(file), endTime)
startTime = time.time()
count = count + 1
return (good, bad, ugly)
accuracy = 0
accuracy5 = 0
recall = 0
precision = 0
for root, d, files in os.walk(v_data_dir):
for name in files:
print(i)
imagePath = str(v_data_dir) + str(name)
if not imagePath.endswith("JPEG"):
continue
img = image_utils.load_img(imagePath, target_size=(224, 224))
temp = image_utils.img_to_array(img)
temp = np.expand_dims(temp, axis=0)
temp = preprocess_input(temp)
preds = TopModel.predict(temp)
P = decode_predictions(preds, par)
(imagenetID, label, prob, index) = P[0][0]
print("Predicted Label : " + str(label))
print("ImageNet ID : " + str(imagenetID))
print("Value Prob : " + str(prob))
print("Predicted Label : " + str(index))
if index in predMat:
predMat[index] += 1
else:
predMat[index] = 1
#print(preds)
fName = str(name)
allLabels = dict()
al = 0
for y in range(0, par):
else:
if include_top:
weights_path = get_file(
'vgg16_weights_tf_dim_ordering_tf_kernels.h5',
TF_WEIGHTS_PATH,
cache_subdir='models')
else:
weights_path = get_file(
'vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5',
TF_WEIGHTS_PATH_NO_TOP,
cache_subdir='models')
model.load_weights(weights_path)
if K.backend() == 'theano':
convert_all_kernels_in_model(model)
return model
if __name__ == '__main__':
model = VGG16(include_top=True, weights='imagenet')
img_path = 'elephant.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)
print('Input image shape:', x.shape)
preds = model.predict(x)
print('Predicted:', decode_predictions(preds))
convert_all_kernels_in_model(model)
else:
if include_top:
weights_path = get_file('resnet50_weights_tf_dim_ordering_tf_kernels.h5',
TF_WEIGHTS_PATH,
cache_subdir='models',
md5_hash='a7b3fe01876f51b976af0dea6bc144eb')
else:
weights_path = get_file('resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5',
TF_WEIGHTS_PATH_NO_TOP,
cache_subdir='models',
md5_hash='a268eb855778b3df3c7506639542a6af')
model.load_weights(weights_path)
if K.backend() == 'theano':
convert_all_kernels_in_model(model)
return model
if __name__ == '__main__':
model = ResNet50(include_top=True, weights='imagenet')
img_path = 'elephant.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)
print('Input image shape:', x.shape)
preds = model.predict(x)
print('Predicted:', decode_predictions(preds))
