functions.py

import matplotlib.pyplot as plt
import tensorflow as tf
from keras.layers import Input, Conv2D, MaxPooling2D, Dense, GlobalAveragePooling2D ,concatenate
from keras.models import Model
from keras import layers
from keras.layers import Flatten, Concatenate, Dropout, BatchNormalization
from keras.applications.densenet import DenseNet121
from keras.regularizers import l2
import pydicom
import cv2
import numpy as np

LABELS = [ 'Atelectasis', 'Cardiomegaly', 'Effusion', 'Infiltration', 'Mass', 'Nodule', 'Pneumonia',
                'Pneumothorax', 'Consolidation', 'Edema', 'Emphysema', 'Fibrosis', 'Pleural_Thickening', 'Hernia']
# tf.compat.v1.enable_eager_execution()
IMAGE_SIZE= 224
#Load Model
tf.compat.v1.disable_eager_execution()  
def chexnet(input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3), num_classes=14, weights_path=None):
    # tf.compat.v1.enable_eager_execution()
    tf.compat.v1.disable_eager_execution()
    # tf.compat.v1.enable_eager_execution()
    input_layer = Input(shape=input_shape, name='input_1')

    base_model = DenseNet121(weights=None, include_top=False, input_tensor=input_layer)

    if weights_path is not None:
        base_model.load_weights(weights_path, by_name=True)

    for layer in base_model.layers:
        layer.trainable = False

    x = base_model.output
    x = GlobalAveragePooling2D()(x)
    predictions = Dense(num_classes, activation='softmax')(x)  # Adjust num_classes based on your task

    model = Model(inputs=base_model.input, outputs=predictions)

    return model

## get image arrays from dicom file
def get_array(dicom_path):
    dcm_data = pydicom.dcmread(dicom_path)
    array= dcm_data.pixel_array
    resized_image = cv2.resize(array, (224, 224))

    # Convert grayscale to 3-channel RGB if needed
    img = cv2.cvtColor(resized_image, cv2.COLOR_GRAY2RGB)

    return img

def grad_cam(input_model, image, cls, layer_name):
    """GradCAM method for visualizing input saliency."""
    # prediction
    y_c = input_model.output[0, cls]
    conv_output = input_model.get_layer(layer_name).output
    print( conv_output)
    # prediction= m.predict(image)
    # with tf.GradientTape() as g:
       
    grads = K.gradients(y_c, conv_output)[0]
    # Normalize if necessary
    # grads = normalize(grads)
    grads = tf.convert_to_tensor(grads)
    print(grads)
    gradient_function = K.function([input_model.input], [conv_output, grads])

    output, grads_val = gradient_function([image])
    output, grads_val = output[0, :], grads_val[0, :, :, :]

    weights = np.mean(grads_val, axis=(0, 1))
    cam = np.dot(output, weights)

    # Process CAM
    cam = cv2.resize(cam, (224, 224), cv2.INTER_LINEAR)
    cam = np.maximum(cam, 0)
    cam_max = cam.max() 
    if cam_max != 0: 
        cam = cam / cam_max
    return cam

def compute_gradcam(model, img, selected_labels, layer_name='bn'):
    """
    Computes the GradCAM for the given image and labels.

    Args:
        model: The Keras model to use for computing the GradCAM.
        img: The preprocessed image.
        labels: The list of labels for the image.
        selected_labels: The list of labels to generate GradCAMs for.
        layer_name: The name of the layer to use for computing the GradCAM.

    Returns:
        A list of GradCAMs for the selected labels.
    """

    # Preprocess the image
    processed_img = np.expand_dims(img, axis=0)

    # Make a prediction on the image
    predictions = model.predict(processed_img)

    # Create a list to store the GradCAMs
    gradcams = []

    # Iterate over the selected labels
    for i in range(len(LABELS)):
        if labels[i] in selected_labels:
            # Compute the GradCAM for the current label
            gradcam = grad_cam(model, processed_img, i, layer_name)

            # Add the GradCAM to the list
            gradcams.append(gradcam)

    return gradcams

# def visualize_gradcam(img, gradcams, labels, predictions):
def visualize_gradcam(img, gradcams, predictions):
    """
    Visualizes the GradCAMs for the given image and labels.

    Args:
        img: The preprocessed image.
        gradcams: The list of GradCAMs to visualize.
        labels: The list of labels for the image.
        predictions: The list of predictions for the image.

    Returns:
        A list of GradCAMs drawn on the image.
    """

    # Create a figure to display the GradCAMs
    fig, axs = plt.subplots(1, len(gradcams) + 1, figsize=(15, 10))

    # Plot the original image
    axs[0].imshow(img, cmap='gray')
    axs[0].axis('off')
    axs[0].set_title("Original")

    # Plot the GradCAMs
    gradcam_images = []
    for i, gradcam in enumerate(gradcams):
        axs[i + 1].imshow(img, cmap='gray')
        axs[i + 1].imshow(gradcam, cmap='jet', alpha=min(0.5, predictions[0][i]))
        axs[i + 1].axis('off')
        axs[i + 1].set_title(f"{LABELS[i]}: p={predictions[0][i]:.3f}")

        # Convert the GradCAM to an image
        gradcam_image = np.array(axs[i + 1].figure.canvas.renderer._renderer.buffer_rgba())

        # Add the GradCAM image to the list
        gradcam_images.append(gradcam_image)

    # Close the figure
    plt.close(fig)

    return gradcam_images


def get_predicted_label(predictions, labels):
    # Find the index of the highest probability in the predictions array
    max_prob_index = predictions.argmax()

    # Retrieve the corresponding label from the labels list
    predicted_label = labels[max_prob_index]

    return predicted_label

def compute_gc(model, img, labels, selected_labels,
                    layer_name='bn'):
    # preprocessed_input = load_image(img, image_dir, df)
    prep_img= np.resize(img, ( 1, 224, 224, 3))
    # processed_img= np.expand_dims(prep_img, axis=0)
    print(img.shape)
    # with graph.as_default():
        
    predictions = model.predict(prep_img)

    print("Loading original image")
    plt.figure(figsize=(15, 10))
    plt.subplot(151)
    plt.title("Original")
    plt.axis('off')
    plt.imshow(np.resize(img, ( 224, 224, 3)), cmap='gray')

    j = 1
    for i in range(len(labels)):
        if labels[i] in selected_labels:
            print(f"Generating gradcam for class {labels[i]}")
            gradcam = grad_cam(model, prep_img, i, layer_name)
            print(gradcam.shape)
            plt.subplot(151 + j)
            plt.title(f"{labels[i]}: p={predictions[0][i]:.3f}")
            plt.axis('off')
            plt.imshow(img,cmap='gray')
            plt.imshow(gradcam, cmap='jet', alpha=min(0.5, predictions[0][i]))
            j += 1