[PYTHON] SmoothGrad mit Chainer v2 implementiert

Einführung

Bei der Bilderkennung ist es wichtig zu visualisieren, wo der Klassifikator fokussiert und erkannt hat. CNN hat ein Verfahren vorgeschlagen, um den Gradienten der Verlustfunktion durch Rückausbreitung auf das Eingabebild zu übertragen und die Intensität seines Absolutwerts zu visualisieren, aber es gab ein Problem, dass es verrauscht war. SmoothGrad ist eine sehr einfache Möglichkeit, dem Eingabebild ein Gaußsches Rauschen zu verleihen und für eine saubere Visualisierung nur mehrere Farbverläufe zu mitteln.

Wie es gemittelt wird

Smooth Grad

Vanilla Grad (konventionelle Methode)

Der TensorFlow-Code und die Papiere können wie folgt heruntergeladen werden. https://tensorflow.github.io/saliency/

Ich habe auch SmoothGrad implementiert, um Chainer v2 zu studieren. Das Modell ist ein trainiertes VGG16-Modell. Die Umwelt ist Windows7 64bit Python 3.5.2 |Anaconda 4.2.0 (64-bit) Die Version von Chainer ist '2.0.0'. GPU wird nicht unterstützt.

Implementierung

import

smoothgrad.py

import chainer
import chainer.functions as F
from chainer.variable import Variable
from chainer.links import VGG16Layers
from PIL import Image
import numpy as np
import matplotlib.pyplot as plt

config Wir machen das im Testmodus, aber wir müssen also die Rückübertragung durchführen Stellen Sie chainer.config wie folgt ein.

smoothgrad.py

chainer.config.train=False
chainer.config.enable_backprop=True

Modellstraße VGG16

Laden Sie das Modell VGG16. Das Modell hat eine Größe von ca. 500 MB. Wenn es also nicht im Voraus heruntergeladen wurde, dauert es einige Zeit.

smoothgrad.py

model = VGG16Layers()

Laden und Vorverarbeiten von Bildern

Die Bildgröße von VGG beträgt 224 x 224, ändern Sie also die Größe.

smoothgrad.py

image = Image.open("cheetah.png ")
image = image.resize((224,224))

Parameter

Stellen Sie die Anzahl der Samples und den Rauschpegel ein. Die Anzahl der Samples beträgt 100 und der Rauschpegel 20%.

smoothgrad.py

sampleSize = 100
noiseLevel = 0.2 # 20%
sigma = noiseLevel*255.0

Gradientenberechnung

Aufgrund des verwendeten Speichers werden wir diesmal nacheinander vorgehen. Erstens ist in VGG16 die Kanalanordnung BGR, also konvertieren Sie sie und subtrahieren Sie den Durchschnittswert. Als nächstes werden beim Hinzufügen von Bildrauschen Vorwärtsausbreitung und -verlust berechnet, und Rückwärtsausbreitung wird verwendet, um den Gradienten zu berechnen. Fügen Sie den erhaltenen Farbverlauf zur Liste hinzu.

smoothgrad.py

gradList = []
for _ in range(sampleSize):
    x = np.asarray(image, dtype=np.float32)
    # RGB to BGR
    x = x[:,:,::-1]
    #Subtrahieren Sie den Durchschnitt
    x -= np.array([103.939, 116.779, 123.68], dtype=np.float32)
    x = x.transpose((2, 0, 1))
    x = x[np.newaxis]
    #Rauschen hinzufügen
    x += sigma*np.random.randn(x.shape[0],x.shape[1],x.shape[2],x.shape[3])    
    x = Variable(np.asarray(x))
    #FP und nehmen Sie die letzte Schicht heraus
    y = model(x, layers=['prob'])['prob']
    #BP mit dem höchsten Vorhersageetikett
    t = np.zeros((x.data.shape[0]),dtype=np.int32)
    t[:] = np.argmax(y.data)
    t = Variable(np.asarray(t))
    loss = F.softmax_cross_entropy(y,t)
    loss.backward()
    #Farbverlauf zur Liste hinzufügen
    grad = np.copy(x.grad)
    gradList.append(grad)
    #Löschen Sie den Farbverlauf
    model.cleargrads()

Visualisierung

Nehmen Sie den maximalen Absolutwert für jeden Kanal des Verlaufs und mitteln Sie ihn für das Bild.

smoothgrad.py

G = np.array(gradList)
M = np.mean(np.max(np.abs(G),axis=2),axis=0)
M = np.squeeze(M)
plt.imshow(M,"gray")
plt.show()

Ergebnis

Während ich die durchschnittliche Anzahl der Blätter erhöhte, versuchte ich, das Originalbild und die Karte für jedes Pixel zu visualisieren.

1 Probe

2 Proben

3 Proben

10 Proben

20 Proben

30 Proben

50 Proben

75 Proben

100 Proben

Wenn Sie aus einem Beispiel ohne Rauschen visualisieren, können Sie wie unten gezeigt viel Rauschen sehen.