def run_net_on_mrc_and_save(net_path,
protein_mrc_path,
prob_output_mrc_path=None,
binary_output_mrc_path=None):
"""
loads a trained neural network, reads a cryo-EM map, runs the neural network on the cryo-EM map, applies a cutoff
to the resulted map in order to round the values to either 0 or 1, and saves the original resulted map and
he masked map to .mrc files.
:param net_path: path of the trained neural network
:param protein_mrc_path: path of the input cryo-EM map
:param prob_output_mrc_path: path to save the .mrc prediction
:param binary_output_mrc_path: path to save the .mrc binary mask of the prediction
:return: the resulted helix prediction map
"""
net = model.load_net(net_path)
protein_data = torch.Tensor(
dataset_manager.read_mrc(protein_mrc_path)).to('cuda')
label_data = run_net_on_whole_protein(net, protein_data)
actual_label_data_tensor = torch.Tensor(label_data).to('cuda')
binary_label_data_tensor = dataset_manager.apply_cutoff(
actual_label_data_tensor, 0.5)
if prob_output_mrc_path != None:
dataset_manager.save_mrc(label_data, prob_output_mrc_path)
if binary_output_mrc_path != None:
binary_label_data = binary_label_data_tensor.cpu().numpy()
dataset_manager.save_mrc(binary_label_data, binary_output_mrc_path)
# to calculate metrics uncomment the next line
#metrics= validate_prediction(binary_label_data_tensor, dataset_manager.read_mrc(protein_mrc_path.split('.')[0] + '_helix.mrc')) # make it a comment later
return label_data
'--threshold',
type=float,
default=0.2,
help=
'to suppress the corresponding CAM by the threshold of its maximum value')
parser.add_argument('--to_visualize',
type=bool,
default=True,
help='Save the CAMs as heatmap images for visualization')
parser.add_argument('--to_save',
type=bool,
default=False,
help='Save the CAMs as numpy array for further processing')
opt = parser.parse_args()
net = model.load_net(opt.model_name, opt.classes, opt.checkpoint_path).cuda()
finalconv_name = 'conv'
params = list(net.parameters())
# get weight only from the last layer(linear)
weight_softmax = params[-1].cpu().data
##========== Extract CAM for all classes with softmax normalization ==================#
def returnCAMs(feature_conv, weight_softmax, threshold=0.):
bz, nc, h, w = feature_conv.shape
features = feature_conv.reshape(nc, h * w).transpose(0, 1) #(hxw, nc)
CAMs = torch.mm(features, weight_softmax.transpose(0, 1)) #(hxw, k)
CAMs = CAMs - torch.min(CAMs, dim=0)[0]
CAMs = CAMs / torch.max(CAMs, dim=0)[0]
# threshold the corresponding CAM by the set ratio of its maximum value
from torch.nn import functional as F
import cv2
import numpy as np
import torchvision.transforms as transforms
import utils
import model
if not os.path.exists('./result'):
os.mkdir('result/')
classes = ('airplance', 'bird', 'car', 'cat', 'deer', 'dog', 'horse', 'monkey',
'ship', 'truck')
test_loader = utils.load_data_stl10(batch_size=1, test=True)
is_cuda = torch.cuda.is_available()
device = torch.device("cuda" if is_cuda else "cpu")
net = model.load_net().to(device)
finalconv_name = 'conv'
# hook
feature_blobs = []
def hook_feature(module, input, output):
feature_blobs.append(output.cpu().data.numpy())
net._modules.get(finalconv_name).register_forward_hook(hook_feature)
params = list(net.parameters())
# get weight only from the last layer(linear)
weight_softmax = np.squeeze(params[-2].cpu().data.numpy())
import torch
import torch.nn as nn
from torch.autograd import Variable
import cv2
import numpy as np
import utils
import os
import torchvision.transforms as transforms
from torch.nn import functional as F
if os.path.exists('./result'):
os.mkdir('result/')
test_loader = utils.load_data_STL10(batch_size=1, test=True)
net = model.load_net()
finalconv_name = 'conv'
# hook
feature_blobs = []
def hook_feature(module, input, output):
feature_blobs.append(output.data.cpu().numpy())
net._modules.get(finalconv_name).register_forward_hook(hook_feature)
params = list(net.parameters())
# get only weight from last layer(linear)
weight_softmax = np.squeeze(params[-2].cpu().data.numpy())