[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

Recommended Posts

J'ai essayé d'implémenter Grad-CAM avec keras et tensorflow
J'ai essayé d'implémenter Autoencoder avec TensorFlow
J'ai essayé d'implémenter et d'apprendre DCGAN avec PyTorch
J'ai essayé de visualiser AutoEncoder avec TensorFlow
J'ai essayé d'implémenter CVAE avec PyTorch
J'ai essayé d'implémenter la lecture de Dataset avec PyTorch
J'ai essayé de déplacer GAN (mnist) avec keras
J'ai essayé d'implémenter PCANet
J'ai touché Tensorflow et keras
J'ai essayé d'implémenter StarGAN (1)
J'ai essayé de lire et d'enregistrer automatiquement avec VOICEROID2 2
J'ai essayé d'implémenter Mine Sweeper sur un terminal avec python
J'ai essayé de lire et d'enregistrer automatiquement avec VOICEROID2
J'ai essayé d'implémenter le perceptron artificiel avec python
J'ai essayé d'implémenter SSD avec PyTorch maintenant (Dataset)
J'ai essayé de trouver la classe alternative avec tensorflow
J'ai essayé de créer une API de reconnaissance d'image simple avec Fast API et Tensorflow
J'ai essayé d'implémenter Deep VQE
J'ai essayé de mettre en place une validation contradictoire
J'ai essayé d'implémenter Realness GAN
J'ai essayé d'implémenter une ligne moyenne mobile de volume avec Quantx
J'ai essayé de prédire et de soumettre les survivants du Titanic avec Kaggle
J'ai essayé de trouver la moyenne de plusieurs colonnes avec TensorFlow
J'ai essayé de mettre en œuvre une évasion (type d'évitement de tromperie) avec Quantx
J'ai essayé d'implémenter ListNet d'apprentissage de rang avec Chainer
J'ai essayé de mettre en œuvre le chapeau de regroupement de Harry Potter avec CNN
J'ai essayé de créer une interface graphique à trois yeux côte à côte avec Python et Tkinter
J'ai essayé d'implémenter SSD avec PyTorch maintenant (édition du modèle)
J'ai essayé d'implémenter PLSA en Python
J'ai essayé d'implémenter la permutation en Python
J'ai essayé de visualiser les signets volant vers Slack avec Doc2Vec et PCA
J'ai essayé de rendre le deep learning évolutif avec Spark × Keras × Docker
Comparez le TensorFlow brut avec tf.contrib.learn et Keras
J'ai essayé de classer le texte en utilisant TensorFlow
J'ai essayé de faire un processus d'exécution périodique avec Selenium et Python
J'ai essayé d'implémenter ADALINE en Python
J'ai essayé d'implémenter la classification des phrases par Self Attention avec PyTorch
J'ai essayé d'implémenter PPO en Python
J'ai essayé de créer des taureaux et des vaches avec un programme shell
J'ai essayé de résoudre TSP avec QAOA
[Deep Learning from scratch] J'ai essayé d'implémenter la couche sigmoïde et la couche Relu
J'ai essayé de convertir la chaîne datetime <-> avec tzinfo en utilisant strftime () et strptime ()
J'ai essayé d'apprendre l'angle du péché et du cos avec le chainer
J'ai implémenté le modèle VGG16 avec Keras et essayé d'identifier CIFAR10
J'ai essayé de contrôler la bande passante et le délai du réseau avec la commande tc
J'ai essayé de prédire l'année prochaine avec l'IA
J'ai essayé d'utiliser lightGBM, xg boost avec Boruta
J'ai essayé d'apprendre le fonctionnement logique avec TF Learn
J'ai implémenté DCGAN et essayé de générer des pommes
J'ai essayé de détecter rapidement un mouvement avec OpenCV
J'ai essayé la décomposition matricielle non négative (NMF) avec TensorFlow
J'ai essayé de jouer en connectant PartiQL et MongoDB
J'ai essayé la différenciation jacobienne et partielle avec python
J'ai essayé d'obtenir des données CloudWatch avec Python
J'ai essayé la synthèse de fonctions et le curry avec python
J'ai essayé de sortir LLVM IR avec Python
J'ai essayé d'implémenter TOPIC MODEL en Python
J'ai essayé d'automatiser la fabrication des sushis avec python