def main(): #Set up argument parser for console input parser = argparse.ArgumentParser(description='Predict category of flower') parser.add_argument('image_path', help='path of image to be analyzed') parser.add_argument( 'checkpoint_dir', help= 'directory containing /checkpoint.pth with pre-trained model to be used for prediction' ) parser.add_argument('--top_k', help='number of top K most likely classes', default=1, type=int) parser.add_argument('--category_names', help='Select JSON file') parser.add_argument('--gpu', help='Enable GPU', action='store_true') args = parser.parse_args() #Load pre-trained model from checkpoint loaded_model, optimizer, criterion, epochs = fu.load_checkpoint( args.checkpoint_dir + '/checkpoint.pth') #Set mode device = torch.device( 'cuda' if torch.cuda.is_available() and args.gpu == True else 'cpu') print('Device is: ', device) #Inference calculation probs, classes = fu.predict(args.image_path, loaded_model, args.top_k, device, args.category_names) print(probs) print(classes)
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 main(): # Get CLI arguments args = get_input_args() # Build model from checkpoint model = functions.load_checkpoint(args.checkpoint) # Get probabilities, labels and flower name from prediction function top_probs, top_labels, top_flowers = functions.predict( args.image_path, model, args.category_name, args.gpu, args.top_k) # Print result for i in zip(top_probs, top_labels, top_flowers): print(i)
def main(): parser = argparse.ArgumentParser( description='This program predicts a flower name from an image') parser.add_argument('image_path', type=str, help='Image path') parser.add_argument('checkpoint', type=str, help='Checkpoint') parser.add_argument('--top_k', type=int, default='1', help='Top k probablities') parser.add_argument('--category_names', type=str, default='cat_to_name.json', help='Mappings of indices and class names') parser.add_argument('--gpu', action='store_true', help='Use GPU', default=False) args = parser.parse_args() device = torch.device("cuda:0" if torch.cuda.is_available() else 'cpu' ) if args.gpu else 'cpu' with open(args.category_names, 'r') as f: cat_to_name = json.load(f) model_load, optimizer_load, scheduler_load, epoch = load_checkpoint( device, args.checkpoint) probs, classes, flowers = predict(model_load, process_image(args.image_path), cat_to_name, args.top_k) print("Predictions for {}: {}".format(args.image_path, flowers)) probs = np.array(probs)[0] print("Probablities: {}".format(probs))
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)
results = parser.parse_args() save_dir = results.save_directory 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)
import pandas as pd import os import shutil import functions # 1. Directory Setting save_directory = r'D:/#.Secure Work Folder/1. Data/1. CMI/1. FLD/test4_result/5-4/' image_directory = r"D:\#.Secure Work Folder\1. Data\1. CMI\1. FLD\test3\5-4\20200830" # 2. Create DataFrame for results result_df = pd.DataFrame(columns=['ID', 'FILE', '1', '2', '3', 'JUDGE']) # 3. load trained model model_save_path = r"C:/Users/LG/Desktop/ksb/3. CODE/model/" filename = 'sepa_image_classifier_crop.pth' model = functions.load_checkpoint(model_save_path, filename) # 4. Classfiying images and reorganize image based on the JUDGE from model for root, dirs, files in os.walk(image_directory): for file in files: if os.path.isdir(save_directory + root[-13:]) == False: os.mkdir(save_directory + root[-13:]) if file.endswith("NG(0).JPG"): print(root[-13:]) print(file) probs, classes = functions.predict(os.path.join(root, file), model) result_df = result_df.append( {
args = parser.parse_args() device = torch.device( 'cuda:0' if torch.cuda.is_available() else 'cpu') if args.gpu else 'cpu' top_k = args.k_value category_names = args.cat_names image_path = args.image_dir save_dir = args.save_directory arch = args.model_arch # Label mapping with open(category_names, 'r') as f: cat_to_name = json.load(f) # Load the model model = getattr(models, arch)(pretrained=True) model = load_checkpoint(model, save_dir) # Make predictions probs, classes = predict(process_image(image_path), model, top_k, device) flower_names = [cat_to_name[item] for item in classes] # Print predicted flower names with top K classes print("The flower is most likely to be a:") for k in range(top_k): print( "Number: {}/{}.. ".format(k + 1, top_k), "Class name: {}.. ".format(flower_names[k]), "Probability: {:.3f}..% ".format(probs[k] * 100), )
# Example call: # python check.py flowers --arch resnet18 --learning_rate 0.001 --epochs 1 --dropout 0.2 --gpu import torch import train import predict import functions as fu original_model, test_loader, criterion = train.main() #Load pre-trained model from checkpoint loaded_model, optimizer, criterion, epochs = fu.load_checkpoint('/home/workspace/aipnd-project/checkpoints/checkpoint.pth') #Set mode device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print('Device is: ', device) fu.compare_orig_vs_loaded(device, original_model, loaded_model, test_loader, criterion)
action="store", default='cat_to_name.json') #call parser and store variables 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)
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))
checkpoint_dir = results.checkpoint_dir test_image_path = results.test_image_path topk = results.topk cat_to_name = results.cat_to_name gpu_mode = results.gpu with open(cat_to_name, 'r') as f: cat_to_name = json.load(f) # load model backbone checkpoint = torch.load(checkpoint_dir) load_arch = checkpoint['model structure'] model = getattr(models, load_arch)(pretrained=True) # load model checkpoint loaded_model = load_checkpoint(model, checkpoint_dir) # Image processing (included in the 'predict' function) and predict the top classification probs, classes = predicting(gpu_mode, test_image_path, loaded_model, topk=topk) print(probs) print(classes) names = [] index = 0 for i in classes: names += [cat_to_name[i]] print("This flower is likely to be: ", names[index], ", with a probability of ", probs[index]) index += 1
def main(argv): parser = argparse.ArgumentParser( description='Predict flower name from an image.', prog='predict.py', formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('image_path', type=str, nargs=1, default=['flowers/test/1/image_06754.jpg'], help='Path to the image to use for prediction.') parser.add_argument('checkpoint', type=str, nargs=1, default=['checkpoint.pth'], help='Path to the checkpoint containing the model.') parser.add_argument('--top_k', type=int, nargs=1, default=[1], help='Return top K most likely classes.') parser.add_argument('--category_names', type=open, nargs=1, default=['cat_to_name.json'], help='Use a mapping of categories to real names.') parser.add_argument('--gpu', nargs='?', const='cuda', help='Use GPU for inference.') args = vars(parser.parse_args(argv)) image_path = args['image_path'][0] checkpoint = args['checkpoint'][0] topK = args['top_k'][0] category_names_file = args['category_names'][0] device = args['gpu'] if device == None: device = 'cpu' print('parameters used for prediction:') print('-------------------------------') print('image_path = {}'.format(image_path)) print('checkpoint = {}'.format(checkpoint)) print('topK = {}'.format(topK)) print('category_names_file = {}'.format(category_names_file)) print('device = {}'.format(device)) model = functions.load_checkpoint(checkpoint) model.eval() model.to(device) data_transforms = { 'train': transforms.Compose([ transforms.RandomRotation(45), transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]), 'valid': transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]), 'test': transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) } # TODO: Load the datasets with ImageFolder image_datasets = { data_type: datasets.ImageFolder(os.path.join('flowers', data_type), data_transforms[data_type]) for data_type in ['train', 'valid', 'test'] } # TODO: Using the image datasets and the trainforms, define the dataloaders dataloaders = { data_type: torch.utils.data.DataLoader(image_datasets[data_type], batch_size=32, shuffle=True) for data_type in ['train', 'valid', 'test'] } # TODO: Display an image along with the top 5 classes with open(category_names_file, 'r') as f: cat_to_name = json.load(f) flower_class = image_path.split('/')[2] title = cat_to_name[flower_class] probas, classes = functions.predict(image_path, model, cat_to_name, topk=topK) print() print('image of {} has been predicted as:'.format(title)) print('------------------------------------------') for index in range(len(classes)): print('{} : {:.2f}%'.format(classes[index], 100 * probas[index]))
from functions import load_checkpoint, predict, show_results parser = argparse.ArgumentParser(description='Create Your Own Image Classifier - Command Line Application - Predict') #Image parser.add_argument('image_path', action='store', default='./flowers/test/78/image_01856.jpg', help = 'Enter an image path', type=str) #Checkpoint parser.add_argument('checkpoint', action='store', default='checkpoint.pth', help = 'Enter a checkpoint to load', type=str) #Choose GPU use parser.add_argument('--gpu', dest='gpu', action='store_true', default=False, help = 'Turn on the use of GPU') #topk parser.add_argument('--top_k', dest='top_k', action='store', default=5, help = 'Return top K predictions', type=int) #category_names parser.add_argument('--category_names', dest='category_names', action='store', default="cat_to_name.json", help = 'Category names to match with model', type=str) arguments = parser.parse_args() image_path = arguments.image_path checkpoint = arguments.checkpoint top_k = arguments.top_k gpu = arguments.gpu category_names = arguments.category_names #Load checkpoint print("Loading model from : {}\n".format(checkpoint)) model = load_checkpoint(checkpoint) #Predict probs, classes = predict(image_path, model, gpu, top_k) #Show results show_results(image_path, probs, classes, category_names)
#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]))
default='cat_to_name.json') ap.add_argument('--gpu', default="gpu", action="store", dest="gpu") pa = ap.parse_args() path_image = pa.input_img number_of_outputs = pa.top_k power = pa.gpu input_img = pa.input_img path = pa.checkpoint model, _, _ = functions.setup() training_loader, testing_loader, validation_loader, train_data = functions.data( ) functions.load_checkpoint(path) with open('cat_to_name.json', 'r') as json_file: cat_to_name = json.load(json_file) probabilities = functions.predict(path_image, model, number_of_outputs, power) labels = [ cat_to_name[str(index + 1)] for index in np.array(probabilities[1][0]) ] probability = np.array(probabilities[0][0]) i = 0 while i < number_of_outputs: print("{} with a probability of {}".format(labels[i], probability[i])) i += 1
gpu = arguments.gpu arch = arguments.arch # set torch.device cuda/cpu device = set_device(gpu) # open the json file with the flower classes with open(cat_file, 'r') as f: cat_to_name = json.load(f) # get the specified model model = getattr(models, arch)(pretrained=True) # load our checkpoint print('Loading checkpoint...\n') model = load_checkpoint(model, device, checkpoint_path) print('Checkpoint loaded!\n') # process the image print('Processing image...\n') proc_image = process_image(input_path) # run the prediction print('Running prediction...\n') probs, classes = predict(proc_image, model, top_k, device) # get the flower names flowers = [cat_to_name[i] for i in classes] # print the top_k number of flowers and probabilities print('\nThe top ' + str(top_k) + ' classes and probabilities are: ')
import functions import argparse parser = argparse.ArgumentParser(description='parser_for_predict') parser.add_argument('image_path', default="./flowers/test/100/image_07896.jpg", type=str) parser.add_argument('checkpoint', default="./checkpoint.pth", type=str) parser.add_argument('--top_k', dest="top_k", default = 5, type=int) parser.add_argument('--category_names', dest="category_names", default='cat_to_name.json') parser.add_argument('--gpu', dest="gpu", default=True, type=bool) parsed = parser.parse_args() image_path = parsed.image_path checkpoint = parsed.checkpoint top_k = parsed.top_k category_names = parsed.category_names gpu = parsed.gpu model, optimizer, idx_to_class = functions.load_checkpoint(checkpoint) cat_to_name = functions.map_label(category_names) functions.predict(image_path, model, top_k, gpu, cat_to_name, idx_to_class)
default='cat_to_name.json', help='Mapping of categories to real names') parser.add_argument('gpu', action='store', help='Use GPU', choices=['GPU', 'CPU']) args = parser.parse_args() image_path = args.path_to_image model_arch = args.arch save_directory = args.save_directory topk = args.top_k category_names = args.category_names gpu = args.gpu if gpu == 'GPU': device = torch.device("cuda" if torch.cuda.is_available() else "cpu") else: device = "cpu" with open('cat_to_name.json', 'r') as f: cat_to_name = json.load(f) model = functions.load_checkpoint(model_arch, save_directory, gpu) probs, top_classes = functions.predict(image_path, model, topk) names = [cat_to_name[cl] for cl in top_classes] print(probs) print(top_classes) print(names)
shuffle=False) loader_test2, idx_to_class_test2 = f.loader(root=DATA_PATH_TEST2, transform=TRANSFORM, batch_size=BATCH_SIZE, shuffle=False) n_batches = len(loader_train) n_batches_test = len(loader_test) # Networks m = network.DQN(RESOLUTION, RESOLUTION, N_ACTIONS) m = m.to(DEVICE) o = optim.Adam(m.parameters(), lr=1e-5) start_epoch = 0 run = f.Run(CHECKPOINT_DIR) start_epoch, m, o = f.load_checkpoint(run.get_checkpoint('32'), m, o) # validate_model(m, loader_test, idx_to_class_test) for epoch in range(N_EPOCHS): print('\n Epoch {}'.format(start_epoch + epoch)) train_model(m, o, loader_train, idx_to_class_train) checkpoint = { 'epoch': start_epoch + epoch + 1, 'state_dict': m.state_dict(), 'optimizer': o.state_dict() } f.save_checkpoint(checkpoint, CHECKPOINT_DIR, start_epoch + epoch) print('FIRST VALIDATION')
default=5, type=int) parser.add_argument('--category_names', dest="category_names", action="store", default='cat_to_name.json') results = parser.parse_args() image_path = results.img_file checkpoint = results.checkpoint gpu = results.gpu topk = results.top_k cat = results.category_names model = functions.load_checkpoint(checkpoint) with open(cat, 'r') as f: cat_to_name = json.load(f) probs, classes = functions.predict(image_path, model, topk) print(probs) print(classes) names = [] for i in classes: names += [cat_to_name[i]] print("Name: {} Probability {}% ".format(names[0], round(100 * acc / total, 3)))
args = parser.parse_args() print('arguments are', args) checkpoint_path = str(Path(args.save_dir) / args.chpt_fn) pre_folder = str(Path(args.pre_dir) / args.pre_folder) pre_img = random.choice(os.listdir(pre_folder)) pre_img_path = pre_folder + '/' + pre_img print(pre_img_path) 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)) }"
action="store", dest="cat_names", default="cat_to_name.json") parser.add_argument('--top_k', action="store", dest="top_k", type=int, default=1) parser.add_argument('--gpu', action="store", dest="gpu", default="gpu") parse_args = parser.parse_args() # 'flowers/test/1/image_06752.jpg' image_path = parse_args.path_to_image # 'checkpoint.pth' save_path = parse_args.checkpoint cat_names = parse_args.cat_names top_k = parse_args.top_k gpu = parse_args.gpu #load saved model model, device, output_units, criterion, optimizer = load_checkpoint( save_path, gpu) #category names cat_to_name = label_mapping(cat_names) #predict plotting(image_path, model, top_k, cat_to_name)