```this is my code how can i include the heat_maps
# Define your transforms for the training and validation sets
# Data augmentation and normalization for training
# Just normalization for validation
data_transforms = {
'train': transforms.Compose([
transforms.RandomRotation(30),
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
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])
]),
}
# Load the datasets with ImageFolder
data_dir = 'clasii'
image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x),
data_transforms[x])
for x in ['train', 'test']}
# Using the image datasets and the transforms, define the dataloaders
dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=4,
shuffle=True, num_workers=0)
for x in ['train', 'test']}
dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'test']}
class_names= image_datasets['train'].classes
# Write a function that loads a checkpoint and rebuilds the model
def load_checkpoint(filepath):
checkpoint = torch.load(filepath)
model = models.resnet152()
# our input_size matches the in_features of pretrained model
input_size = 2048
output_size = 2
classifier = nn.Sequential(OrderedDict([
('fc1', nn.Linear(2048, 1024)),
('relu', nn.ReLU()),
#('dropout1', nn.Dropout(p=0.2)),
('fc2', nn.Linear(1024, 2)),
('output', nn.LogSoftmax(dim=1))
]))
# Replacing the pretrained model classifier with our classifier
model.fc = classifier
model.load_state_dict(checkpoint['state_dict'])
return model, checkpoint['class_to_idx']
# Get index to class mapping
loaded_model, class_to_idx = load_checkpoint('90_checkpoint.pth')
idx_to_class = { v : k for k,v in class_to_idx.items()}
def visualize_model(model, num_images=6):
was_training = model.training
model.eval()
images_so_far = 0
fig = plt.figure()
with torch.no_grad():
for i, (inputs, labels) in enumerate(dataloaders['test']):
inputs = inputs.to(device)
labels = labels.to(device)
outputs = model(inputs)
_, preds = torch.max(outputs, 1)
for j in range(inputs.size()[0]):
images_so_far += 1
ax = plt.subplot(num_images//2, 2, images_so_far)
ax.axis('off')
ax.set_title('predicted: {}'.format(class_names[preds[j]]))
imshow(inputs.cpu().data[j])
if images_so_far == num_images:
model.train(mode=was_training)
return
model.train(mode=was_training)
def process_image(image):
''' Scales, crops, and normalizes a PIL image for a PyTorch model,
returns an Numpy array
'''
# Process a PIL image for use in a PyTorch model
size = 256, 256
image.thumbnail(size, Image.ANTIALIAS)
image = image.crop((128 - 112, 128 - 112, 128 + 112, 128 + 112))
npImage = np.array(image)
npImage = npImage/255.
imgA = npImage[:,:,0]
imgB = npImage[:,:,1]
imgC = npImage[:,:,2]
imgA = (imgA - 0.485)/(0.229)
imgB = (imgB - 0.456)/(0.224)
imgC = (imgC - 0.406)/(0.225)
npImage[:,:,0] = imgA
npImage[:,:,1] = imgB
npImage[:,:,2] = imgC
npImage = np.transpose(npImage, (2,0,1))
return npImage
def imshow(image, ax=None, title=None):
"""Imshow for Tensor."""
if ax is None:
fig, ax = plt.subplots()
# PyTorch tensors assume the color channel is the first dimension
# but matplotlib assumes is the third dimension
image = image.numpy().transpose((0, 2, 0))
# Undo preprocessing
mean = np.array([0.485, 0.456, 0.406])
std = np.array([0.229, 0.224, 0.225])
image = std * image + mean
# Image needs to be clipped between 0 and 1 or it looks like noise when displayed
image = np.clip(image, 0, 1)
ax.imshow(image)
return ax
def predict(image_path, model, topk=2):
''' Predict the class (or classes) of an image using a trained deep learning model.
'''
# Implement the code to predict the class from an image file
image = torch.FloatTensor([process_image(Image.open(image_path).convert('RGB'))])
model.eval()
output = model.forward(Variable(image))
probabilities = torch.exp(output).data.numpy()[0]
top_idx = np.argsort(probabilities)[-topk:][::-1]
top_class = [idx_to_class[x] for x in top_idx]
top_probability = probabilities[top_idx]
return top_probability, top_class
# Display an image along with the top classes
def view_classify(img, probabilities, classes, mapper):
''' Function for viewing an image and it's predicted classes.
'''
img_filename = 'Prediction'
img = Image.open(img)
fig, (ax1, ax2) = plt.subplots(figsize=(6,10), ncols=1, nrows=2)
ct_name = img_filename
ax1.set_title(ct_name)
ax1.imshow(img)
ax1.axis('off')
y_pos = np.arange(len(probabilities))
ax2.barh(y_pos, probabilities, color='green')
ax2.set_yticks(y_pos)
ax2.set_yticklabels(x for x in classes)
ax2.invert_yaxis()
plt.show()
