def main(image_path, checkpoint, device, topk=1, category_name=None):
model = h.load_checkpoint(checkpoint)
probs, classes = predict(image_path, model, topk, device)
# get probs and classes out of tensors
probs = probs.cpu().detach().numpy()[0]
classes = classes.cpu().numpy()[0]
# map class number to name if JSON provided
if category_name:
mapping = h.load_mappings(category_name)
classes = list(map(lambda x: mapping.get(str(x)), classes))
return probs[0], classes
def main():
# 1. Getting Input Arguments
args = get_input_arg()
# 2. Loading Checkpoint (Trained Model)
model, model_spec = load_checkpoint(args.checkpoint)
# 3. Image Preprocessing
np_img = process_image(args.input)
# 4. further processing to fit numpy image to the trained model
img = process_image_to_tensor(np_img)
# 5. Decide using CPU or GPU for Prediction
device = torch.device("cuda:0" if (
torch.cuda.is_available() and args.gpu) else "cpu")
print(f"Device used for prediction: {device}")
# 6. Class Prediciton
df_topk_predict, predicted_class = class_predict(img, model, device,
args.top_k)
# 7. Parse Class inx back to label
df = parse_idx_to_label(df_topk_predict, args.category_names, model_spec)
print(f"Top {args. top_k} Prediciton: \n {df}")
results = parser.parse_args()
img_path = results.img_path
checkpoint_path = results.checkpoint_path
top_k = results.top_k
category_names = results.category_names
gpu = results.switch
if gpu == True:
using_gpu = torch.cuda.is_available()
device = 'gpu'
print('gpu On')
else:
print('gpu Off')
device = 'cpu'
model = utility_functions.load_checkpoint(checkpoint_path)
processed_image = utility_functions.process_image(img_path)
probs, classes = utility_functions.predict(processed_image, model, top_k,
device)
# Label mapping
cat_to_name = utility_functions.labeling(category_names)
labels = []
for class_index in classes:
labels.append(cat_to_name[str(class_index)])
# Converting from tensor to numpy-array
print('Name of class: ', labels)
print('Probability: ', probs)
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
training_loader, testing_loader, validation_loader = utility_functions.load_data(
)
utility_functions.nn_setup(structure, dropout, hidden_layer1, lr, power)
model_conv, criterion, optimizer_conv = nn_setup(structure, dropout,
hidden_layer1, lr, power)
utility_functions.load_checkpoint(path)
with open('cat_to_name.json', 'r') as json_file:
cat_to_name = json.load(json_file)
probabilities = utility_functions.predict(path_image, model_conv,
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]))
print()
print("Image network will predict flower image on {}, on the {} likely "
"classes, using category name mapping {}, and gpu {}".format(
image_path, top_k, category_names, gpu))
print()
# load our feature detector model
model = models.vgg13(pretrained=True)
model.classifier = Classifier(25088, 102, [500], drop_p=.2)
# used trained model checkpoint from part 1
checkout_point_dir = "/home/workspace/SavedModels"
# load model checkpoint
try:
model, model_class_to_idx = load_checkpoint(
checkout_point_dir + "/checkpoint.pth", model)
except:
print("Can not find provided model checkpoint. Please try again.")
exit()
# predicts the flower image's class
try:
if gpu == "gpu":
device = torch.device(
"cuda:0" if torch.cuda.is_available() else "cpu")
else:
device = "cpu"
probs, classes = predict(image_path, device, model, top_k)
except:
print("Can not find provided image or provided top K is invalid. "
"Please try again.")
parser.add_argument("--gpu",
help="Optionally use GPU for inference",
action="store_true")
args = vars(parser.parse_args())
args_dict = dict(
filter(lambda elem: (elem[1] != None) and (elem[1] != False),
args.items()))
kwargs_mapping = {
k: v
for (k, v) in args_dict.items() if k in ['category_names']
}
cat_to_name = utility.load_class_mapping(**kwargs_mapping)
model, optimizer = utility.load_checkpoint(args_dict['checkpoint'])
kwargs_predict = {
k: v
for (k, v) in args_dict.items() if k in ['top_k', 'gpu']
}
probs, classes = model_functions.predict(args_dict['image_path'], model,
**kwargs_predict)
classes_names = [cat_to_name[cl] for cl in classes]
predictions = zip(classes_names, probs)
print("Prediction:")
[
print("{} with a probability of {:.3}".format(cl, p))
for cl, p in predictions
]