def lrp_visualize(R_lrp, gamma=args.gamma):
    heatmaps_lrp = []
    for h, heat in enumerate(R_lrp):
        heat = heat.permute(1, 2, 0).detach().cpu().numpy()
        maps = render.heatmap(heat, reduce_axis=-1, gamma_=gamma)
        heatmaps_lrp.append(maps)
    return heatmaps_lrp
예제 #2
0
파일: utils.py 프로젝트: Juna2/RSR-LRP_tmp
def visualize3(R_lrp, R_lrp34, R_grad, image_tensor, epoch, j, prediction):
    try:
        os.makedirs(args.img_dir + args.img_name + str('/'))  ##
    except OSError:
        pass

    heatmaps_lrp = []
    heatmaps_lrp34 = []
    heatmaps_grad = []

    # 0. input images
    input_shape = image_tensor.shape
    images = image_tensor.permute(0, 2, 3, 1).cpu().detach().numpy()
    images = images - images.min(axis=(1, 2, 3), keepdims=True)
    images = images / images.max(axis=(1, 2, 3), keepdims=True)

    #     images = images - images.min()
    #     images = images / images.max()

    # 1. LRP
    for h, heat in enumerate(R_lrp):
        heat = heat.permute(1, 2, 0).detach().cpu().numpy()
        maps = render.heatmap(heat, reduce_axis=-1)
        heatmaps_lrp.append(maps)

    # 2. LRP34

    R_lrp34 = R_lrp34.squeeze(1).permute(1, 2, 0)
    R_lrp34 = R_lrp34.detach().cpu().detach().numpy()
    R_lrp34 = cv2.resize(R_lrp34, (224, 224))
    R_lrp34.reshape(input_shape[2], input_shape[3], input_shape[0])

    for i in range(input_shape[0]):
        heatmap = np.float32(
            cv2.applyColorMap(np.uint8(
                (1 - R_lrp34[:, :, i]) * 255), cv2.COLORMAP_JET)) / 255
        cam = heatmap + np.float32(images[i])
        cam = cam / np.max(cam)
        heatmaps_lrp34.append(cam)

    # 3. Grad_CAM

    R_grad = R_grad.squeeze(1).permute(1, 2, 0)
    R_grad = R_grad.cpu().detach().numpy()
    R_grad = cv2.resize(R_grad, (224, 224))
    R_grad.reshape(input_shape[2], input_shape[3], input_shape[0])

    for i in range(input_shape[0]):
        heatmap = np.float32(
            cv2.applyColorMap(np.uint8(
                (1 - R_grad[:, :, i]) * 255), cv2.COLORMAP_JET)) / 255
        cam = heatmap + np.float32(images[i])
        cam = cam / np.max(cam)
        heatmaps_grad.append(cam)

    R_lrp = np.array(heatmaps_lrp, dtype=np.float32)
    R_lrp34 = np.array(heatmaps_lrp34, dtype=np.float32)
    R_grad = np.array(heatmaps_grad, dtype=np.float32)

    image_path = args.img_dir
    img_name = args.img_name
    prediction_dic = {}

    l = min(args.batch_size_test, args.num_visualize_plot)
    for i in range(l):
        file_name = 'lrp_epoch' + str(epoch) + '_no-' + str(i + l * j) + '.png'
        prediction_dic['lrp_epoch' + str(epoch) + '_no-' +
                       str(i + l * j)] = prediction[i]
        path = os.path.join(image_path + img_name + str('/'), file_name)  ##
        imsave(path, R_lrp[i], plugin='pil')

    for i in range(l):
        file_name = 'lrp34_epoch' + str(epoch) + '_no-' + str(i +
                                                              l * j) + '.png'
        prediction_dic['lrp34_epoch' + str(epoch) + '_no-' +
                       str(i + l * j)] = prediction[i]
        path = os.path.join(image_path + img_name + str('/'), file_name)  ##
        imsave(path, R_lrp34[i], plugin='pil')

    for i in range(l):
        file_name = 'grad_epoch' + str(epoch) + '_no-' + str(i +
                                                             l * j) + '.png'
        prediction_dic['grad_epoch' + str(epoch) + '_no-' +
                       str(i + l * j)] = prediction[i]
        path = os.path.join(image_path + img_name + str('/'), file_name)  ##
        imsave(path, R_grad[i], plugin='pil')

    for i in range(l):
        file_name = 'ori_epoch' + str(epoch) + '_no-' + str(i + l * j) + '.png'
        prediction_dic['ori_epoch' + str(epoch) + '_no-' +
                       str(i + l * j)] = prediction[i]
        path = os.path.join(image_path + img_name + str('/'), file_name)  ##
        imsave(path, images[i], plugin='pil')

    prediction_dic = sorted(prediction_dic.items(), key=operator.itemgetter(0))
    np.save(
        args.img_dir + args.img_name + str('/') + args.img_name +
        '_prediction.npy', prediction_dic)
예제 #3
0
파일: utils.py 프로젝트: Juna2/RSR-LRP_tmp
def visualize2(relevances, epoch, prediction, images_tensor=None, shape=None):
    try:
        os.makedirs(args.img_dir + args.img_name + str('/'))  ##
    except OSError:
        pass

    print('relevance shape', relevances.shape)
    n, dim, h, w = relevances.shape
    heatmaps = []
    oris = []
    # import pdb;pdb.set_trace()
    if args.model in ['CNN8', 'VGG19']:
        images_tensor = images_tensor.reshape(
            [args.batch_size_test, 3, 224, 224])
    else:
        images_tensor = images_tensor.reshape(
            [args.batch_size_test, 1, 28, 28])
    if images_tensor is not None:
        assert relevances.shape == images_tensor.shape, 'Relevances shape != Images shape'


#     heatmaps = render.heatmap(relevances.cpu().numpy(),reduce_axis=1)
#     oris = render.image(images_tensor.cpu().numpy())

#     ori = oris - oris.min(axis=0)
#     ori = ori / ori.max(axis=0)

    for h, heat in enumerate(relevances):
        if images_tensor is not None:
            print(2, heat.shape)
            input_image = images_tensor[h].permute(1, 2,
                                                   0).detach().cpu().numpy()
            heat = heat.permute(1, 2, 0).detach().cpu().numpy()
            #maps = render.hm_to_rgb(heat, input_image, scaling=3, sigma=2, shape=shape)
            maps = render.heatmap(heat, reduce_axis=-1)
            #ori = render.image(input_image)
            ori = input_image - input_image.min()
            ori = ori / ori.max()
        else:
            heat = heat.cpu().numpy()
            #maps = render.hm_to_rgb(heat, scaling=3, sigma=2, shape=shape)
            maps = render.heatmap(heat, reduce_axis=0)
            #ori = render.image(input_image)
            ori = input_image - input_image.min()
            ori = ori / ori.max()

        heatmaps.append(maps)
        oris.append(ori)

    R = np.array(heatmaps, dtype=np.float32)
    #R = np.transpose(R,(0,3,2,1))
    ori = np.array(oris, dtype=np.float32)
    #ori= np.transpose(ori,(0,3,2,1))

    # save R to img file
    # print('---- R shape---',R.shape)
    # print('--- img saved in utils.py in def visualize. change file name every time----')
    # imsave('../results/test/180225_lrp_module.png', R[1])
    # np.save('../results/test/180225_R.npy',R)
    image_path = args.img_dir
    img_name = args.img_name
    prediction_dic = {}

    for i in range(min(args.batch_size_test, args.num_visualize_plot)):
        #path = os.path.join(image_path, 'results{}.png'.format(i))
        #file_name = img_name + str(i) + '.png'
        file_name = 'lrp_epoch' + str(epoch) + '_no-' + str(i) + '.png'
        prediction_dic['lrp_epoch' + str(epoch) + '_no-' +
                       str(i)] = prediction[i]
        path = os.path.join(image_path + img_name + str('/'), file_name)  ##
        imsave(path, R[i], plugin='pil')

    for i in range(min(args.batch_size_test, args.num_visualize_plot)):
        #path = os.path.join(image_path, 'results{}.png'.format(i))
        #file_name = img_name + str(i) + '.png'
        file_name = 'ori_epoch' + str(epoch) + '_no-' + str(i) + '.png'
        prediction_dic['ori_epoch' + str(epoch) + '_no-' +
                       str(i)] = prediction[i]
        path = os.path.join(image_path + img_name + str('/'), file_name)  ##
        imsave(path, ori[i], plugin='pil')

    prediction_dic = sorted(prediction_dic.items(), key=operator.itemgetter(0))
    np.save(
        args.img_dir + args.img_name + str('/') + args.img_name +
        '_prediction.npy', prediction_dic)