[PYTHON] J'ai essayé d'implémenter Grad-CAM avec keras et tensorflow

introduction

Cette fois, j'ai implémenté GradCAM sur mon propre modèle CNN. J'utilise Google Colaboratory, mais je pense qu'il peut être utilisé localement ou dans un notebook Jupyter.

Le modèle CNN sera AlexNet, qui a été implémenté et formé à l'aide de keras.

Puisque l'image est celle utilisée dans la recherche proprement dite, elle ne peut pas être publiée, veuillez donc la lire en fonction de l'environnement si vous souhaitez vous y référer.

Qu'est-ce que Grad-CAM?

Qu'est-ce que Grad-CAM en premier lieu? Qui est Où dans l'image se trouve l'apprentissage en profondeur! ?? Vérifiez la différence entre "Oshiyaki" et "Pizza" avec CNN Veuillez consulter l'article de plus près.

Public cible

――Je sais qu'il existe Grad-CAM, mais comment l'implémentez-vous réellement? Les gens qui sont --Personnes souffrant de la version tensorflow --Les personnes qui ont vu d'autres articles mais qui ont des problèmes avec l'erreur ↓ (je ne sais pas ...)

> RuntimeError: tf.gradients is not supported when eager execution is enabled. Use tf.GradientTape instead.

version

Vérifiez la version avant de passer à l'implémentation Mettez le code suivant dans la cellule et vérifiez la version

import tensorflow as tf
import keras
print('tensorflow version: ', tf.__version__)
print('keras version: ', keras.__version__)

Résultat d'exécution

tensorflow version:  2.3.0
keras version:  2.4.3

la mise en oeuvre

Faisons ce dont nous avons besoin en premier Montez le lecteur Google avec la commande ↓.

from google.colab import drive
drive.mount('/content/drive')

Définissez le chemin du répertoire courant pour charger l'image ou le modèle. Veuillez modifier le My Drive suivant en fonction de votre environnement.

current_directory_path = '/content/drive/My Drive/Research/AlexNet/'

Importer les modules requis

import numpy as np
import cv2

#Pour les images
from keras.preprocessing.image import array_to_img, img_to_array, load_img
#Pour le chargement du modèle
from keras.models import load_model
#Pour le calcul Grad-CAM
from tensorflow.keras import models
import tensorflow as tf

Définition de constante Veuillez également changer ici en fonction de votre environnement.

IMAGE_SIZE  = (32, 32)

Méthode de calcul Grad-CAM

def grad_cam(input_model, x, layer_name):
    """
    Args: 
        input_model(object):Objet modèle
        x(ndarray):image
        layer_name(string):Le nom de la couche convolutive
    Returns:
        output_image(ndarray):Image colorée de l'image originale
    """

    #Prétraitement d'image
    #Puisqu'il n'y a qu'une seule image à lire, le mode doit être augmenté..Je ne peux pas prévoir
    X = np.expand_dims(x, axis=0)
    preprocessed_input = X.astype('float32') / 255.0    

    grad_model = models.Model([input_model.inputs], [input_model.get_layer(layer_name).output, input_model.output])
    
    with tf.GradientTape() as tape:
        conv_outputs, predictions = grad_model(preprocessed_input)
        class_idx = np.argmax(predictions[0])
        loss = predictions[:, class_idx]

    #Calculer le gradient
    output = conv_outputs[0]
    grads = tape.gradient(loss, conv_outputs)[0]

    gate_f = tf.cast(output > 0, 'float32')
    gate_r = tf.cast(grads > 0, 'float32')

    guided_grads = gate_f * gate_r * grads

    #Faire la moyenne des poids et multiplier par la sortie de la couche
    weights = np.mean(guided_grads, axis=(0, 1))
    cam = np.dot(output, weights)

    #Redimensionnez l'image à la même taille que l'image d'origine
    cam = cv2.resize(cam, IMAGE_SIZE, cv2.INTER_LINEAR)
    #Au lieu de ReLU
    cam  = np.maximum(cam, 0)
    #Calculer la carte thermique
    heatmap = cam / cam.max()

    #Images monochromes pseudo-couleurs
    jet_cam = cv2.applyColorMap(np.uint8(255.0*heatmap), cv2.COLORMAP_JET)
    #Convertir en RVB
    rgb_cam = cv2.cvtColor(jet_cam, cv2.COLOR_BGR2RGB)
    #Combiné avec l'image d'origine
    output_image = (np.float32(rgb_cam) + x / 2)  
    
    return output_image

Calculer Grad-CAM

Commencez par charger le modèle et l'image. Veuillez faire correspondre chaque passe à votre environnement.

model_path = current_directory_path + '/model.hdf5'
image_path = current_directory_path + '/vis_images/1/2014_04_1_3.png'

model = load_model(model_path)
x = img_to_array(load_img(image_path, target_size=IMAGE_SIZE))

Vérifiez si l'image chargée correspond.

array_to_img(x)

Calculer Grad-CAM

target_layer = 'conv_filter5'
cam = grad_cam(model, x, target_layer)

Vérifiez l'image calculée.

array_to_img(cam)

en conclusion

Cette fois, j'ai essayé d'implémenter Grad-CAM avec Google Colaboratory. J'espère que cela aide les personnes qui ont souffert de la version tensorflow.

Je me trompe ici! S'il y a quelque chose comme ça, faites-le moi savoir!

référence

Où dans l'image se trouve l'apprentissage en profondeur! ?? Vérifiez la différence entre "Oshiyaki" et "Pizza" avec CNN Grad CAM implementation with Tensorflow 2