def choiceResult(dbName,imageName,temp=""):
print "Choice --- Executing."
if(not(temp == "")):
testImage = dbName+"/"+imageName+"/"+temp
else:
testImage = dbName+"/"+imageName
print testImage
if platform.system()=="Windows":
look="\\"
else:
look="/"
choiceImage = ""
#do a prediction based on algorithm
if(algoName == "eigenface"):
result = utility.predict(testing[testing_answer.index(testImage)], training_answer, W, mu, projections)
choiceImage = "eigenface_yale_choice"
elif(algoName == "fisherface"):
result = utility.predict(testing[testing_answer.index(testImage)], training_answer, W, mu, projections)
choiceImage = "fisherface_yale_choice"
elif(algoName == "sift"):
result = sift.localPredict(descriptors_testing[testing_answer.index(testImage)], training_answer, descriptors_training)
choiceImage = "sift_yale_choice"
elif(algoName == "lem"):
result = lem.predict_hausdroff(testing_corners[testing_answer.index(testImage)], training_corners, training_answer)
choiceImage = "lem_yale_choice"
#test the image for success based on databases
if(database == "yale A"):
heading=result[result.find(look)+len(look):result.find('.')]+" MATCHED WITH "+ testImage[testImage.find(look)+len(look):testImage.find('.')]
if(result[:result.find('.')] == testImage[:testImage.find('.')]):
print "HIT!"
status="hit"
else:
status="miss"
elif(database == "orl"):
heading=result[result.find(look)+len(look):result.find(look,11)]+" MATCHED WITH "+ testImage[testImage.find(look)+len(look):testImage.find(look,11)]
if(result[:result.find(look,12)] == testImage[:testImage.find(look,12)]):
print "HIT"
status="hit"
else:
status="miss"
elif(database == "yale B"):
pass
#plot the visuals
utility.choicePlot(testImage, result, choiceImage)
os.system("convert "+choiceImage+" "+choiceImage+".png")
os.system("rm static/images/"+choiceImage+".png")
os.system("mv "+choiceImage+".png static/images/"+choiceImage+".png")
return render_template("choiceResult.html", filename = "/static/images/"+choiceImage+".png", status=status, heading=heading)
def main():
user_args = get_input_args()
model, class_labels = utility.load_saved_model()
cat_to_name = utility.load_json(user_args.category_names)
probs, labels, _ = utility.predict(user_args.input, model, user_args.top_k,
cat_to_name, class_labels,
user_args.gpu)
print("------------------Processing------------------")
for i in range(len(probs)):
result_label = labels[i]
result_prob = probs[i] * 100
print("The probability of the {} is {:.2f} %.".format(
result_label, result_prob))
def main():
args = init_argparse()
with open('cat_to_name.json', 'r') as f:
cat_to_name = json.load(f)
model.to(gpu)
model= utility.load_checkpoint('save_dir')
utiltiy.process_image('input_file')
top_f_probability.power().numpy(), f_names=utility.predict(process_image, model, 'topk', 'device', 'flower_names')
utility.probability(top_f_probability, top_f_classes)
def test(filename):
fp = open(filename, 'rb')
data = pickle.load(fp)
fp.close()
weights = data.get('weights')
weights = helper.lists_toarray(weights)
model = utility.getNewModel()
model.set_weights(weights)
X, Y = load_datasets("../",
["mnist-test-images.npy", "mnist-test-labels.npy"])
pred = utility.predict(model, X)
print(np.argmax(pred, axis=1), Y)
print(sum(np.argmax(pred, axis=1) == Y) / Y.shape[0])
def main():
print('Predict')
in_arg = get_input_args()
print("Command Line Arguments:\n input =", in_arg.input, "\n checkpoint =",
in_arg.checkpoint, "\n top_k =", in_arg.top_k, "\n category_names =",
in_arg.category_names, "\n gpu =", in_arg.gpu)
# Load checkpoint
model, checkpoint = load_checkpoint(in_arg.checkpoint)
# Load catagory mapping dictionary
cat_to_name = category_mapping(in_arg.category_names)
# Process the image to return a transposed_image
transposed_image = process_image(in_arg.input)
# Get the prediction for an image file.
top_classes = predict(transposed_image, model, in_arg.top_k, cat_to_name,
in_arg.gpu)
# Print the chart with the top classes and probabilities.
print(top_classes)
def eigenTest(self):
result = utility.predict(self.testing[self.testing_answer.index(self.testImage)], self.training_answer, self.W, self.mu, self.projections)
print result, self.testImage
if(result[6:9] == self.testImage[6:9]):
print "HIT!"
if(self.db == "yale"):
utility.choicePlot("yalefaces/"+self.testImage, "yalefaces/"+result, self.choiceImage)
print "Finished plotting image"
elif(self.db == "orl"):
utility.choicePlot("orl_faces/"+self.testImage, "orl_faces/"+result, self.choiceImage)
elif(self.db == "db3"):
pass
self.choiceResult = tk.Frame(self)
self.choiceResult.place(in_=self.algorithm, x=0,y=0,relwidth=1,relheight=1)
choiceImage = ImageTk.PhotoImage(file=self.choiceImage)
labelChoice = tk.Label(self.choiceResult, image=choiceImage)
labelChoice.image = choiceImage
labelChoice.pack(side="top")
print "should happen"
choiceBack = tk.Button(self.choiceResult, text="Back", command=lambda: self.algorithm.lift())
choiceBack.pack(side="top")
self.choiceResult.lift()
def check_arguments():
"""This function checks the user inputs before using predict function"""
if not path.isfile(image_path):
print(image_path, "file cannot be found!")
sys.exit()
if not path.isfile(model_path):
print(model_path, "model cannot be found!")
sys.exit()
if not path.isfile(labels_dic_file):
print(labels_dic_file, "file cannot be found!")
sys.exit()
if topk <=0:
print("The topk cannot be less than 1")
sys.exit()
# checking user inputs
check_arguments()
# loading labels json file as a dictionary
labels = utility.file_to_dic(labels_dic_file)
#_model, _model_info = utility.load_model()
#print(_model)
#print(_model_info)
# predicts the image and prints out the results
prediction = utility.predict(image_path, model_path, labels, topk, device)
print(prediction)
from torch import optim
import torch.nn.functional as F
from torchvision import datasets, transforms
import torchvision.models as models
from collections import OrderedDict
import PIL
from PIL import Image
import numpy as np
import utility
import argparse
import json
ap = argparse.ArgumentParser(description='predict class of flower')
ap.add_argument('path_img', default='aipnd-project/flowers/test/10/image_07117.jpg', nargs='*', action="store", type = str)
ap.add_argument('checkpoint', default='checkpoint.pth', nargs='*', action="store", type = str)
ap.add_argument('--top_k', default=5, dest="top_k", action="store", type=int)
ap.add_argument('--labels', dest="labels", action="store", default='cat_to_name.json')
ap.add_argument('--gpu', default="gpu", nargs = '*', action="store", dest="gpu")
pa = ap.parse_args()
path_image = pa.path_img
path = pa.checkpoint
with open('cat_to_name.json', 'r') as json_file:
cat_to_name = json.load(json_file)
model = utility.load_checkpoint(path)
utility.predict(path_image, model, topk=5)
while True:
# read video frame
ret, raw_img = cap.read()
# process frames
if raw_img is not None:
h, w, _ = raw_img.shape
img = cv2.cvtColor(raw_img, cv2.COLOR_BGR2RGB)
img = cv2.resize(img, (640, 480))
img_mean = np.array([127, 127, 127])
img = (img - img_mean) / 128
img = np.transpose(img, [2, 0, 1])
img = np.expand_dims(img, axis=0)
img = img.astype(np.float32)
confidences, boxes = ort_session.run(None, {input_name: img})
boxes, labels, probs = predict(w, h, confidences, boxes, 0.7)
# if face detected
if boxes.shape[0] > 0:
x1, y1, x2, y2 = boxes[0, :]
gray = cv2.cvtColor(raw_img, cv2.COLOR_BGR2GRAY)
aligned_face = fa.align(
raw_img, gray,
dlib.rectangle(left=x1, top=y1, right=x2, bottom=y2))
aligned_face = cv2.resize(aligned_face, (112, 112))
cv2.imwrite(f'faces/tmp/{label}_{frame_count}.jpg',
aligned_face)
aligned_face = aligned_face - 127.5
aligned_face = aligned_face * 0.0078125
default="False",
help='use gpu to speed up inference')
args = args.parse_args()
image_path = args.input_img
top_k = args.top_k
gpu = args.gpu
checkpoint = args.checkpoint
category_names = args.category_names
image_path = image_path[1]
path_list = image_path.split('/')
import json
with open(category_names, 'r') as f:
flower_to_name = json.load(f)
flower_species = len(flower_to_name)
target_class = flower_to_name[path_list[-2]] # To get the category
print("Target class: " + target_class)
model = u.load_checkpoint(checkpoint)
value, kclass = u.predict(image_path, model, gpu, top_k)
idx_to_class = {model.class_to_idx[i]: i
for i in model.class_to_idx.keys()} # dict comprehension
classes = [flower_to_name[idx_to_class[c]]
for c in kclass] # list comprehension
data = {'Predicted Class': classes, 'Probablity': value}
dataframe = pd.DataFrame(data)
print(dataframe.to_string(index=False))
params = ['hypercube', 'ball']
for i in range(len(params)):
print('-----scenario', i + 1, '-----')
param = params[i]
if param == 'hypercube':
samples[labels == 1] = hypercube_proj(samples_pos)
samples[labels == -1] = hypercube_proj(samples_neg)
else:
samples[labels == 1] = ball_proj(samples_pos)
samples[labels == -1] = ball_proj(samples_neg)
samples_train, samples_test, labels_train, labels_test = \
train_test_split(samples, labels, test_size=400, random_state=0)
w_initial = np.zeros(dim + 1)
pl.figure(1, (5, 4))
pl.scatter(samples_train[:, 0], samples_train[:, 1], c=labels_train)
pl.show()
T = len(samples_train)
w_hat, _ = stochastic_grad_decent(w_initial, samples_train, labels_train, \
alpha=0.1, max_iterations=T, proj=param)
print(w_hat)
predicted_labels = predict(w_hat, samples_test)
# print(predicted_labels)
# print(labels_train)
t_precision = predicted_labels[np.where(
predicted_labels == labels_test)].size / float(labels_test.size) * 100
print('Accuracy on the training set: %s%%' % round(t_precision, 2))
help='path to the image to be classified')
parser.add_argument('checkpoint',
type=str,
help='path to fetch the saved checkpoint')
parser.add_argument('--top_k',
type=int,
default=3,
help='top K most likely cases')
parser.add_argument('--category_names',
type=str,
default='cat_to_name.json',
help='images mapping to real names')
parser.add_argument('--gpu',
type=bool,
default=True,
help='Whether or not to use gpu or cpu')
args = parser.parse_args()
with open(args.category_names, 'r') as f:
cat_to_name = json.load(f) #read the json file into a dict
img = args.input_image_path
model = load_checkpoint(args.checkpoint)
device = torch.device(
"cuda" if args.gpu and torch.cuda.is_available() else "cpu")
probabilities, classes = predict(img, model.to(device), args.top_k)
category_names = [cat_to_name[str(cl)] for cl in classes]
for name, prob in zip(category_names, probabilities):
print("The Model predicts {} with a probability of {}%\n".format(
name, int(prob * 100)))
import json
parser = argparse.ArgumentParser()
parser.add_argument('input', type=str)
parser.add_argument('--checkpoint', default='icp.pth', type=str)
parser.add_argument('--top_k', default=5, type=int)
parser.add_argument('--mapping', default='cat_to_name.json', type=str)
parser.add_argument('--gpu', action='store_true', default=False)
args = parser.parse_args()
# Load trained model
model = load_model(args.checkpoint)
with open(args.mapping, 'r') as mapping_file:
model.class_to_idx = json.load(mapping_file)
# Convert picture to model input
picture_path = args.input
model_input = tf.from_numpy(process_image(picture_path))
# Get prediction from model
if args.gpu:
device = 'cuda'
else:
device = 'cpu'
model.to(device)
results = predict(model, model_input, top_k=args.top_k, device=device)
# Display results
for name, probability in results:
print('{}: {}%'.format(name, round(float(probability) * 100, 2)))
data_dir = 'flowers'
test_dir = data_dir + '/test'
img_path = results.img_path if results.img_path != None else (
test_dir + '/' + '10/image_07090.jpg')
checkpoint_path = results.checkpoint_path if results.checkpoint_path != None else 'checkpoint.pth'
cat_to_name = results.cat_to_name if results.cat_to_name != None else 'cat_to_name.json'
device = util.devices[
'gpu'] if results.device == 'gpu' or torch.cuda.is_available() else 'cpu'
top_k = results.top_k if results.top_k != None else 5
print('-------------------------')
print('img_path used: ', img_path)
print('checkpoint_path used: ', checkpoint_path)
print('device used: ', device)
print('top_k Used: ', top_k)
print('cat_to_name Used: ', cat_to_name)
#-----------------------------------------------------------
model = helper.load_checkpoint('checkpoint.pth')
model
#print(model)
img_label = img_path.split(test_dir + '/')[1].split('/')[0]
cat_to_name = helper.load_cat_to_name(cat_to_name)
title = cat_to_name[img_label]
print('-------------------------')
print('flower category = ', title)
probs, labs, flowers = util.predict(img_path, model, cat_to_name)
print('probs = ', probs)
print('labs = ', labs)
print('flowers = ', flowers)
parse.add_argument('--category_name',
action='store',
dest='category_name',
default='cat_to_name.json')
parse.add_argument(
'--gpu',
action='store',
dest='gpu',
default='cuda',
help='cpu used by default, to use GPU please specify --gpu "cuda"')
inputArg = parse.parse_args()
imagePath = inputArg.image_loc
checkpoint = inputArg.check_loc
topK = inputArg.top_k
device = inputArg.gpu
categoryName = inputArg.category_name
with open(categoryName, 'r') as f:
cat_to_name = json.load(f)
model = loadModel(checkpoint, device)
probs, flowerList = predict(imagePath, model, topK, device)
flowerNames = []
for flower in flowerList:
flowerNames.append(cat_to_name[flower])
for i in range(0, len(flowerNames)):
print(flowerNames[i])
print(probs[i])
