def predict(image_path, model_path, topk=1, gpu=True): ''' Predict the class (or classes) of an image using a trained deep learning model. ''' model, Mapping_class_idx, epochs_old = load_checkpoint(checkpoint_import) #device = torch.device("cuda" if torch.cuda.is_available() else "cpu") if gpu == True: device = torch.device("cuda") else: device = torch.device("cpu") model.to(device) #### Mapping_idx_class = {v: k for k, v in Mapping_class_idx.items()} ### # Get the image form the file and transform it and covert it to a pytorch tensor of shape [1,3,224,224] np_image = torch.from_numpy(functions.process_image(image_path)) np_image = np_image[:, :, :, None] np_image = np.transpose(np_image, [3, 0, 1, 2]) np_image = np_image.float() np.image = np_image.to(device) #turn off drop outs with torch.no_grad(): model.eval() log_probs = model.forward(np_image.to(device)) probs = torch.exp(log_probs) top_p, top_index = probs.topk( topk, dim=1) # gets the top probabilities and the indices of those probs top_index = top_index.to("cpu").numpy() top_class = [Mapping_idx_class.get(key) for key in top_index[0] ] # gets the classes based on the indices return (top_p.to("cpu").numpy()[0], top_class)
def mosaics(): time_start = time() avg_dic = fn.average_pixel_dic(path) time_end = time() timing = time_end - time_start print('average_pixel_dic time:', timing) image_arr_working = fn.process_image(imageArray, avg_dic, 100, path) new_final_image = Image.fromarray(image_arr_working) new_final_image.show()
def main(): # user inputs from command line in_arg = get_input_args() # load model checkpoint model_checkpoint = load_checkpoint(in_arg.checkpoint) # load and process unseen image data new_image = process_image(in_arg.image_path) # predict on unseen image data probs, classes = predict(new_image, model_checkpoint, in_arg.topk, in_arg.gpu) # get labels get_labels(probs, classes, model_checkpoint)
def get_results(): uploaded_image = session.get('uploaded_image', None) # alpha = request.form["sliderGlare"] inputs = jsonify(request.form).response[0] inputs_dict = json.loads(inputs) message = inputs_dict processed_image, perc_wrinkle = fn.process_image( uploaded_image, threshold_1=int(inputs_dict.get("background", 20)), resize=None, alpha=int(inputs_dict.get('alpha', 60)), beta=int(inputs_dict.get('beta', 0))) message3 = "Percent Wrinkled: %s " % perc_wrinkle fn.plot_wrinkle_class(processed_image, uploaded_image) im = uploaded_image.split('/')[-1].split('.')[0] + '_wrinkle.png' f = os.path.join(app.config['RESULTS_FOLDER'], im) return render_template('results.html', display_image=f, message3=message)
topk = args.topk with open(args.category_names, 'r') as f: cat_to_name = json.load(f) # rebuild the model from checkpoint model_2, optimizer_2 = functions.load_checkpoint(checkpoint_path) print('load finished!') #print(model_2) # open an image for prediction im = Image.open(pre_img_path) #plt.imshow(im) # process the image to tensor im_ts = functions.process_image(im) #helper.imshow(im_ts) print("finish image process") # predict image probs, classes, index = functions.predict(im_ts, model_2, topk) print( f"top {topk:.0f} probabilities are: {list(map(lambda x:round(x, 4), probs)) }" ) print(f"top {topk:.0f} classes are: {classes}") print(f"top {topk:.0f} class index are: {index}") # get flower name classes_name = functions.idx_to_name(index, cat_to_name) print(f"top {topk:.0f} class names are: {classes_name}")
pa = parser.parse_args() checkpoint = pa.checkpoint device = pa.device input_image = pa.input_image top_k = pa.top_k category_names = pa.category_names #check input print("The input variables are:\n", pa) #LOAD CHECKPOINT my_model, optimizer = functions.load_checkpoint(checkpoint) print('\nCheckpoint Loaded') #PROCESS IMAGE test = functions.process_image(input_image) print("\nImage processed") #depending on cpu/gpu usage if torch.cuda.is_available() and device == 'gpu': device = 'cuda' my_model.to(device) #PREDICT CATEGORY NAME with open(category_names, 'r') as f: cat_to_name = json.load(f) probs, classes, names = functions.predict(test, my_model, device, top_k, cat_to_name) print( '\nPredictions made. Here they are, together with their corresponding probability:\n'
parser = argparse.ArgumentParser( description='''Make a flower prediction from a PyTorch checkpoint''', formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('image_path', default=None, help='path to image for prediction') parser.add_argument('checkpoint', default=None, help='path to PyTorch checkpoint for loading a model') parser.add_argument('--top_k', default=1, type=int, help='return top K most likely classes') parser.add_argument('--category_names', default=None, help='json file mapping of categories to real names') parser.add_argument('--gpu', action='store_true', help='predict on a GPU') # Get the args args = parser.parse_args() # Load up a model checkpoint model, checkpoint = functions.load_checkpoint(args.checkpoint, args.gpu) # Preprocess a image to be used for the prediction in the model image = functions.process_image(args.image_path, model) # Make a prediction functions.predict(args.image_path, model, args.gpu, args.top_k, args.category_names)
import preparser as parser from functions import process_image, hydrate, cat_to_name if __name__ == '__main__': arg = parser.parser.parse_args() print(arg) image = process_image(arg.input) network = hydrate(arg.checkpoint) names = cat_to_name(arg.category_names) prediction = network.predict(image, arg.gpu, arg.top_k, names) print(prediction)
image = results.image_path top_k = results.topk gpu_mode = results.gpu cat_names = results.cat_name_dir with open(cat_names, 'r') as f: cat_to_name = json.load(f) # Establish model template pre_tr_model = results.pretrained_model model = getattr(models,pre_tr_model)(pretrained=True) # Load model loaded_model = load_checkpoint(model, save_dir, gpu_mode) # Preprocess image - assumes jpeg format processed_image = process_image(image) if gpu_mode == True: processed_image = processed_image.to('cuda') else: pass # Carry out prediction probs, classes = predict(processed_image, loaded_model, top_k, gpu_mode) # Print probabilities and predicted classes print(probs) print(classes) names = [] for i in classes:
dest='top_k', help='The number of predictions returned.') results = parser.parse_args() image = results.image_path gpu_mode = results.gpu category_names = results.cat_to_name pretrained_model = results.arch top_k = results.top_k with open(category_names, 'r') as f: cat_to_name = json.load(f) model = getattr(models, pretrained_model)(pretrained=True) model_loaded = load_checkpoint(model, checkpoint_path) image_processed = process_image(image) probs, classes = predict(image_processed, model_loaded, top_k) print(probs) print(classes) names = [] for i in classes: names += [cat_to_name[i]] final_percent = round(probs[0] * 100, 4) print("This flower is predicted to be a {} with a probability of {}% ".format( names[0], final_percent))
#Load inputs inputs = inputs() print(inputs) #Assign inputs to variables // Not prompting user for a) saving directory and b) pre-trained model data_dir = inputs.data_dir learning_rate = inputs.learning_rate hidden_layer1 = inputs.hidden_layer1 hidden_layer2 = inputs.hidden_layer2 dropout_prob1 = inputs.dropout_prob1 dropout_prob2 = inputs.dropout_prob2 image_path = inputs.image_path top_k = inputs.top_k use_gpu = inputs.gpu #image processing and predicting model, optimizer, criterion = load_checkpoint('checkpoint_part2.pth', hidden_layer1, hidden_layer2, dropout_prob1, dropout_prob2) tensor_image = process_image(image_path) top_probs, top_labels, top_flowers = predict(tensor_image, model, cat_to_name, top_k) for i in range(0, top_k): print( "Likelihood #{}, with probability {:.4%}, is that this flower is a {} that can be seen in folder with label {}" .format(i + 1, top_probs[i], top_flowers[i], top_labels[i]))
import functions import torch import numpy as np import json import argparse import sys if __name__ == '__main__': # Creating parser for training Arguments = sys.argv[1:] Parser = functions.ArgumentParsers('predict') ParsedArguments = Parser.parse_args(Arguments) # Processing Image ProcessedImage = functions.process_image(ParsedArguments.path_to_image) # Loading Model LoadedModel = functions.Load(ParsedArguments.checkpoint_path) # Predicting Probs, Classes = functions.predict(ProcessedImage, LoadedModel, topk=ParsedArguments.top_k) # Mapping the classes to names FlowerNames = [] if ParsedArguments.category_name != None: try: with open('cat_to_name.json', 'r') as f: cat_to_name = json.load(f) for Class in Classes:
st.write( "==========================================================================================================" ) uploaded_file = st.file_uploader("Choose an image...", type=["png", "jpg", "jpeg"]) if uploaded_file is not None: image = Image.open(uploaded_file) st.image(image, caption='Uploaded Image', use_column_width=True) st.write("") st.write("Classifying...") torch_prediction, tf_prediction_1, tf_prediction_2 = f.make_predictions( image, torch_model, tf_model_1, tf_model_2) torch_label, tf_label_1, tf_label_2 = f.get_label_from_predictions( torch_prediction), f.get_label_from_predictions( tf_prediction_1), f.get_label_from_predictions(tf_prediction_2) st.markdown(f"PyTorch thinks... **{torch_label}**") st.markdown(f"Tensorflow mimicing PyTorch thinks... **{tf_label_1}**") st.markdown(f"Tensorflow thinks... **{tf_label_2}**") st.write("------------") st.write("Creating plots....") st.write( f.plot_comparisons( f.process_image(image)[0], torch_prediction, tf_prediction_1, tf_prediction_2))