def predict_topk(image_path, model, mapping_json, gpu, topk=5):
''' Predict the class (or classes) of an image using a trained deep learning model.
'''
#image showing
print('read in cata-to-name files')
with open(mapping_json, 'r') as f:
cat_to_name = json.load(f)
# gpu or
print('reading in file finished')
if gpu:
model.cuda()
else:
model.cpu()
model.eval()
#image prediction
image = process_image(image_path)
model = model.double()
image = image.transpose((2, 1, 0))
image = torch.from_numpy(image)
image = image.unsqueeze(0)
with torch.no_grad():
log_ps = model(image)
ps = torch.exp(log_ps)
probs, top_class = ps.topk(5, dim=1)
probs, top_class = probs.numpy(), top_class.numpy()
#show the top5 flowers name
flower_names = [cat_to_name[class_] for class_ in classes[0].astype(str)]
for prob, flower_name in zip(probs, flower_name):
print('the probablity of ', flower_name, prob, ' is ', prob * 100, '%')
return probs, top_class
def predict_image(image_path):
#load the model
model = load_checkpoint(args.checkpoint)
if args.gpu:
device = torch.device('cuda')
else:
device = torch.device('cpu')
#Implement the code to predict the class from an image file
image = helper.process_image(image_path)
image = torch.from_numpy(image).float()
image = Variable(torch.FloatTensor(image), requires_grad=True)
image = image.unsqueeze(0)
model = model.to(device)
model.eval()
image = image.to(device)
output = model.forward(image)
prob = torch.exp(output)
prob, classes = prob.topk(arg.top_k, dim=1)
top_prob = prob.data[0].tolist()
top_classes = []
for e in classes.data[0].cpu().numpy():
for key, value in model.class_to_idx.items():
if e == value:
top_classes.append(int(key))
return top_prob, top_classes
def process_video(file_path):
if not os.path.isfile(file_path):
raise ValueError('The file {} does not exist'.format(file_path))
videos_folder = os.path.join(FLAGS.runs_dir, 'videos')
if not os.path.isdir(videos_folder):
os.makedirs(videos_folder)
video_output = os.path.join(videos_folder, os.path.basename(file_path))
with tf.Session(config=_get_config()) as sess:
image_input, logits, keep_prob = _load_model(sess, _model_folder())
reader = imageio.get_reader(file_path)
fps = reader.get_meta_data()['fps']
writer = imageio.get_writer(video_output, fps=fps)
for frame in tqdm(reader, desc='Processing Video', unit='frames'):
frame_processed = helper.process_image(frame, sess, logits,
keep_prob, image_input,
IMAGE_SHAPE)
writer.append_data(frame_processed)
writer.close()
def main():
"""
Executing relevant functions
"""
# Get Keyword Args for Prediction
args = arg_parser()
# Load categories to names json file
with open(args.category_names, 'r') as f:
cat_to_name = json.load(f)
# Load model trained with train.py
model = load_checkpoint(args.checkpoint)
print(model)
# Process Image
image = process_image(args.image_path)
# Check for GPU
device = check_gpu(gpu_arg=args.gpu);
# Use `processed_image` to predict the top K most likely classes
top_ps, top_class = predict(image, model, args.top_k)
# Print out probabilities
print_probability(top_class,cat_to_name, top_ps)
def predict(image_path, model, topk=5, category_names='cat_to_name.json', device="cpu"):
""" Predict the class (or classes) of a flower image using a trained deep learning model.
"""
image = Image.open(image_path)
image = process_image(image).unsqueeze(dim=0)
image = image.type(torch.FloatTensor)
image = image.to(device)
model = model.to(device)
logps = model(image)
ps = torch.exp(logps)
top_ps, top_class = ps.topk(topk, dim=1)
with open(category_names, 'r') as f:
cat_to_name = json.load(f)
idx_to_class = {v: k for k, v in model.class_to_idx.items()}
if topk > 1:
top_ps = [top_p.item() for top_p in top_ps.squeeze()]
top_class = [idx_to_class[top_class.item()] for top_class in top_class.squeeze()]
else:
top_ps = [top_p.item() for top_p in top_ps]
top_class = [idx_to_class[top_class.item()] for top_class in top_class]
top_class_name = [cat_to_name[top_class] for top_class in top_class]
return top_class_name, top_ps
def predict(image_path, model, cat_to_name, topk=5):
'''
Predict the class (or classes) of an image using a trained deep learning model.
'''
# Process image with helper method
img = process_image(image_path)
# Reshape image tensor to match model input
img = img.unsqueeze(0)
img = img.float()
# Retrieve label key matching the index in the dataset at large (Complete unsegmented dataset)
# of the image to it's label
class_to_idx = model.class_to_idx
#Turning off Gradient because we are not training
with torch.no_grad():
# Passing model through model to get prediction log probabilities
output = model.forward(img.to('cuda'))
# Conversion from log to standard probabilities
ps = torch.exp(output)
# Taking top k probabilities and the corresponding labels to those predictions and printing them for
# review by data scientist
probs, classes = ps.topk(topk, dim=1)
prob_list, flow_list = [], []
for prob in probs[0]:
prob_list.append(prob.item())
for cls in classes[0]:
flow_list.append(class_to_idx[str(cls.item()+1)])
lab_list = [cat_to_name[str(cls+1)] for cls in flow_list]
return lab_list, prob_list
def predict(image_path, model, topk=5, cuda = False):
''' Predict the class (or classes) of an image using a trained deep learning model.
'''
# TODO: Implement the code to predict the class from an image file
image = Image.open(image_path)
image = helper.process_image(image)
image = torch.from_numpy(image).type(torch.FloatTensor)
inputs = Variable(image, requires_grad=False)
inputs = inputs.unsqueeze(0)
if cuda:
inputs = inputs.cuda()
model.cuda()
ps = torch.exp(model.forward(inputs))
if cuda:
ps.cuda()
top_probs, top_labels = ps.topk(top_k)
top_probs, top_labels = top_probs.data.cpu().numpy().squeeze(), top_labels.data.cpu().numpy().squeeze()
idx_to_class = {v: key for key, v in model.class_to_idx.items()}
if top_k == 1:
top_classes = [idx_to_class[int(top_labels)]]
top_probs = [float(top_probs)]
else:
top_classes = [idx_to_class[each] for each in top_labels]
return top_probs, top_classes
def predict(image_path, model, topk, device):
''' Predict the class (or classes) of an image using a trained deep learning model.
'''
# TODO: Implement the code to predict the class from an image file
#process the image and show the image
model.to(device)
model.eval()
tensor_img = process_image(image_path)
#the model requires the batch size at the start of the input tensor, use unsqueeze to add a dimension of 1 (batch size=1)
#to dimension 0 of image tensor
tensor_img.unsqueeze_(0)
tensor_img.to(device)
log_results = model.forward(tensor_img)
probs = torch.exp(log_results)
top_p, top_class_idx = probs.topk(topk, dim=1)
#convert top_p, top_class tensor to numpy and then to list.
#Because the variable require Gradient, use var.detach().numpy() instead
top_probs = top_p.detach().numpy().tolist()[0]
top_class_idx = top_class_idx.detach().numpy().tolist()[0]
#map the top_class to flower name using model.class_to_idx.items()
idx_to_class = {val: key for key, val in model.class_to_idx.items()}
top_class_label = [idx_to_class[label] for label in top_class_idx]
return top_probs, top_class_label
def predict(image_path, checkpoint, device, categories_to_names, topk=5):
''' Predict the class (or classes) of an image using a trained deep learning model.
'''
with open(categories_to_names, 'r') as f:
cat_to_name = json.load(f)
# TODO: Implement the code to predict the class from an image file
img = helper.process_image(image_path)
model, class_to_idx = helper.load_checkpoint(
checkpoint) #,optimizer=load_checkpoint(model)
img = torch.Tensor(img)
#unsqueezing recommended on torch discussion forums for error i was having at:
#https://discuss.pytorch.org/t/expected-stride-to-be-a-single-integer-value-or-a-list-of-1-values-to-match-the-convolution-dimensions-but-got-stride-1-1/17140
img = img.unsqueeze(0)
img = img.to(device)
model = model.to(device)
model.eval()
with torch.no_grad():
log_prob = model(img)
probabilities = torch.exp(log_prob)
probs, classes = probabilities.topk(topk, dim=1)
classes = classes.cpu()
classes = classes.numpy()
classification = {
number: string
for string, number in class_to_idx.items()
}
class_names = [cat_to_name[classification[item]] for item in classes[0]]
probs = probs.cpu()
probs = probs.numpy()
return probs[0], class_names
def main(image_path, model_URL, top_k, class_names_file=None):
# Load classnames or assign classnames to none
if class_names_file:
with open(class_names_file, 'r') as f:
class_names = json.load(f)
else:
class_names = None
# Load and compile model from file
model = tf.keras.models.load_model(
model_URL, custom_objects={'KerasLayer': hub.KerasLayer})
# Load and process image to be classified
image = Image.open(image_path)
image = np.asarray(image)
processed_image = h.process_image(image)
processed_image = np.expand_dims(processed_image, axis=0)
# Predict and return results
probabilities = model.predict(processed_image).squeeze()
prob_name_list = h.i_toName(class_names, probabilities)
probs, classes = h.get_topk(prob_name_list, top_k)
print(probs)
print(classes)
return probs, classes
def get_classification(self, image):
"""Determines the color of the traffic light in the image
Args:
image (cv::Mat): image containing the traffic light
Returns:
int: ID of traffic light color (specified in styx_msgs/TrafficLight)
"""
image = process_image(image)
light_class = self.predict(image)
return light_class
def Predict(model, image_path, topk, device):
image = helper.process_image(image_path)
image = image.to(device)
probabilities = torch.exp(model(image))
probability, classes = probabilities.topk(topk, dim=1)
return probability, classes
def predict(image_path, checkpoint, topk, labels, gpu):
''' Predict the class (or classes) of an image using aa trained deep learning model.
'''
#model = helper.get_model(checkpoint)
#new_net = NeuralNetClassifier(
# module=models.Inception_v3,
# criterion=torch.nn.CrossEntropyLoss,
# optimizer= optim.SGD,
# )
#new_net.initialize()
#new_net.load_params(f_params= checkpoint)
model = models.Inception_v3.load_state_dict(
torch.load(checkpoint)['valid_acc_best'])
print(model.eval())
#torch.load(path)
#if gpu:
# model = model.cuda()
# torch.cuda.set_device(3)
#loadvalid_acc_best
image = Image.open(image_path)
#process Image into a tensor
image_tensor = helper.process_image(image)
#if torch.cuda.is_available() and gpu:
# image = image_tensor.to('cuda')
with torch.no_grad():
output = model.forward(image)
#else:
output = model.forward(image_tensor)
#get the probability output
probs = torch.exp(output)
#print(np.isnan(probs.data.numpy()).sum())
top_probs, indices = probs.topk(topk, sorted=True)
print("Probabilities: " + str(top_probs))
print("Indices: " + str(indices))
if torch.cuda.is_available() and gpu:
# Added softmax here as per described here:
# https://github.com/pytorch/vision/issues/432#issuecomment-368330817
probs = torch.nn.functional.softmax(top_probs.data,
dim=1).cpu().numpy()[0]
classes = indices.data.cpu().numpy()[0]
else:
probs = torch.nn.functional.softmax(top_probs.data, dim=1).numpy()[0]
classes = indices.data.numpy()[0]
print(classes)
#print(probs)
print(probs)
return probs, classes
def predict(image_path, model, topk):
model.to(device)
model.eval()
imaget = h.process_image(image_path)
imaget.to(device)
imaget = imaget.unsqueeze(0)
image = imaget.type(torch.cuda.FloatTensor)
output = model.forward(image)
ps = torch.exp(output)
model.train()
return ps.topk(topk)
def predict(image_path, model, topk=5, device='cuda'):
im = Image.open(image_path)
processed_image = process_image(im).unsqueeze(0)
model.to(device)
model.eval()
with torch.no_grad():
processed_image = processed_image.to(device).float()
output = model(processed_image)
ps = torch.exp(output)
pred = ps.topk(topk)
flower_ids = pred[1][0].to('cpu')
flower_ids = torch.Tensor.numpy(flower_ids)
probs = pred[0][0].to('cpu')
idx_to_class = {k: v for v, k in checkpoint['class_to_idx'].items()}
flower_names = np.array([cat_to_name[idx_to_class[x]] for x in flower_ids])
return probs, flower_names
def sanity_check(image_path):
probs, labels = predict(image_path, model, args.top_k)
ps = [x for x in probs.cpu().detach().numpy()[0]]
npar = [x for x in labels.cpu().numpy()[0]]
names = list()
inv_mapping = {v: k for k, v in model.class_to_idx.items()}
for i in npar:
names.append(cat_to_name[str(inv_mapping[i])])
h.imshow(h.process_image(image_path), ax=plt.subplot(2, 1, 1))
plt.title(names[0])
plt.subplot(2, 1, 2)
sb.barplot(y=names, x=ps, color=sb.color_palette()[0])
plt.show()
def predict(model):
if (model == None):
model = helper.load_checkpoint()
image_path = helper.get_file_path(
'\nPlease enter the path of the image you want to analyse\n')
topk = helper.get_int(
'\nPlease enter how many to the top predictions you want to see (topk)\n'
)
device = helper.get_device()
model = helper.load_device(model)
image_tensor = helper.process_image(image_path).to(device)
idx_to_class = helper.get_idx_to_class()
print('\nPredicting\n')
with torch.no_grad():
output = model.forward(image_tensor)
ps = torch.exp(output)
topK_ps = torch.topk(ps, topk)
probs = topK_ps[0].cpu().numpy().squeeze()
sorted_ps_label_keys = topK_ps[1].cpu().numpy().squeeze()
get_label = lambda x: idx_to_class[str(x)]
classes = []
for i in sorted_ps_label_keys[0:topk]:
classes.append(get_label(i))
print('\nFinished predicting\n')
return probs, classes
parser.add_argument('--image_path',
type=str,
help='Path to file',
default='flowers/test/28/image_05230.jpg')
parser.add_argument('--gpu', type=bool, default=True, help='GPU or CPU')
parser.add_argument('--topk', type=int, help='K prediction', default=0)
args = parser.parse_args()
image_path = args.image_path
with open(args.cat_to_name_json, 'r') as f:
cat_to_name = json.load(f)
model, checkpoint = load_checkpoint(args.checkpoint)
im = Image.open(image_path)
processed_image = process_image(im)
def predict(image_path, model, topk=5, device='cuda'):
im = Image.open(image_path)
processed_image = process_image(im).unsqueeze(0)
model.to(device)
model.eval()
with torch.no_grad():
processed_image = processed_image.to(device).float()
output = model(processed_image)
ps = torch.exp(output)
pred = ps.topk(topk)
flower_ids = pred[1][0].to('cpu')
flower_ids = torch.Tensor.numpy(flower_ids)
probs = pred[0][0].to('cpu')
import helper
parser = argparse.ArgumentParser(description='Image Classifier')
parser.add_argument('--inp_image',type = str, default = 'flowers/valid/1/image_06755.jpg', help = 'Path to dataset directory')
parser.add_argument('--checkpoint',type=str,default='trained1.pth',help='Checkpoint')
parser.add_argument('--gpu',type=str,default='cpu',help='GPU')
parser.add_argument('--json_class',type=str,default='cat_to_name.json',help='JSON of key value')
parser.add_argument('--top_k',type=int,default=5,help='Top k classes and probabilities')
args=parser.parse_args()
class_to_name= helper.load_class(args.json_class)
model=helper.load(args.checkpoint)
print(model)
vals=torch.load(args.checkpoint)
image = helper.process_image(args.inp_image)
helper.imshow(image)
probs, classes = helper.predict(args.inp_image, model, args.top_k, args.gpu)
print(probs)
print(classes)
helper.display_image(args.inp_image, class_to_name, classes,probs)
import argparse
from helper import load_checkpoint, process_image, predict, convertJSON
# Get data from command line
parser = argparse.ArgumentParser( description ='Script to predict the probability of type of flower in supplied image' )
parser.add_argument("image_path", help="Path to image for processing" )
parser.add_argument("checkpoint", help="Name and path for checkpoint file containing the trained network" )
parser.add_argument("--category_name", help="The path and name of *.json file containing the mapping of flower categories")
parser.add_argument("--top_k", help="Top probabilities to return. Between 1 to 102", type=int, default=3 )
parser.add_argument("--gpu", help="Train model via GPU", action="store_true", default=False)
args = parser.parse_args()
# Load the checkpoint and rebuild the model
model = load_checkpoint(args.checkpoint)
# Process image
tmp = process_image(args.image_path)
# Inference
top_k_probs, classes = predict(args.image_path, model, args.top_k, args.gpu )
print("Top K probabilities: {}".format( top_k_probs ))
if args.category_name == None:
print("classes: {}".format( classes ))
else:
cat_to_name = convertJSON( args.category_name )
index_to_class = {val: key for key, val in model.class_to_idx.items()}
top_classes = [index_to_class[each] for each in classes]
names = [cat_to_name[x] for x in top_classes]
print("Names of top K flowers: {}".format( names ))
print('top_k = {}'.format(top_k))
print('category_names = {}'.format(category_names))
print('gpu = {}'.format(gpu))
print('--------------------------------')
# Load Categories
with open('cat_to_name.json', 'r') as f:
cat_to_name = json.load(f)
# Load checkpoint
device = 'cuda' if gpu else 'cpu'
model, criterion, optimizer, class_labels = helper.load_checkpoint(
device, checkpoint_path)
# Process image
image = helper.process_image(image_path)
image_tensor = torch.from_numpy(image).type(torch.FloatTensor)
image_tensor.resize_([1, 3, 224, 224])
model.eval()
model.to(device)
image_tensor = image_tensor.to(device)
result = model(image_tensor)
result = torch.exp(result)
probs, idx = result.topk(top_k)
probs.detach_()
probs.resize_([top_k])
probs = probs.tolist()
import argparse
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Image Classification application')
parser.add_argument(dest="image_path", default ="flowers/test/28/image_05230.jpg" ,action="store",help = "provide path to image, the path should look similar to this 'flowers/test/28/image_05230.jpg'")
parser.add_argument(dest = "checkpoint",default = "ImageClassifier/final_checkpoint.pth", action="store",help = "paste in the checkpoint saved from training, default: ImageClassifier/final_checkpoint.pth")
parser.add_argument("--top_k",dest = "top_k",default = 5, type=int, action="store",help = "how many most likely classes to display, default = 5")
parser.add_argument("--device",dest = 'device', action="store", default='cpu',help = "device for prediction,default cpu")
parser.add_argument("-c""--category_names",dest = "category_names",default = "cat_to_name.json", action="store",help = "the file to map categories to real names, default: 'cat_to_name.json' located on the working directory")
args = parser.parse_args()
loaded_model = load_checkpoint(args.checkpoint)
top_probs, top_class_label = predict(args.image_path, loaded_model, args.top_k, args.device)
max_probs = max(top_probs)
im_tensor = process_image(args.image_path)
with open(args.category_names, 'r') as f:
cat_to_name = json.load(f)
img_label = cat_to_name[args.image_path.split('/')[-2]]
print('***Prediction Results***')
print('*top_probs:', top_probs)
print('*top_class_label"', top_class_label)
top_flowers = [cat_to_name[label] for label in top_class_label]
print('*top_flowers:', top_flowers)
print("*max class probability:", top_probs[0],
"*predicted class label:", top_class_label[0],
"*predicted flower:", top_flowers[0])
print("*True Image class label:", args.image_path.split('/')[-2], "-"
"*True Image label:", img_label)
def process_image(image):
return helper.process_image(sess, logits, keep_prob,
image_input, image, IMAGE_SHAPE)
# --- # %% # %load_ext autoreload # %autoreload 2 # %% import numpy as np import matplotlib.pyplot as plt from skimage.draw import disk import helper # %% shape = (100, 100) image = np.zeros(shape) _, _ = helper.process_image(image) # %% image = np.ones(shape) recon_image, recon_image_sart = helper.process_image(image, with_fragment=True) # %% helper.plot_two_images(recon_image[:60, :20], recon_image_sart[:60, :20]) # %% helper.plot_two_graphs(recon_image[71, :], recon_image_sart[71, :]) # %% image = np.ones(shape) image = np.pad(image, 20) recon_image, recon_image_sart = helper.process_image(image)
