[SOLVED] Machine Learning 2 Week 11-DL3

In [2]: %matplotlib inline

# ————————————– # TODO: Replace by your code
# ————————————– import solution solution.gradinput(model,X,cl)

# --------------------------------------

We observe that the explanation is noisy and has a large amount of positive and negative evidence. To produce a more robust explanation, we would like to use instead LRP, and implement it using the trick described in the slides. The trick consists of detaching certain terms from the differentiation graph, so that the explanation can obtained by performing Gradient × Input with the modified gradient.

LRP rules are typically set different at each layer. In VGG-16, we distinguish the following three types of layers of parameters:

First convolution: This convolution receives pixels as input, and it requires a special rewrite rule that we given below.
Next convolutions: All remaining convolutions receives activations as input, and we can treat them using LRP-γ.
Dense layers: For these layers, we want to let the standard gradient signal flow, so we can simply leave these layers intact.

LRP in First Convolution

This convolution implements the propagation rule:

xw −lw+−hw− R=∑ iij iij iij R

i ∑ xiwij −liw+ −hiw− j j0,i ijij

where (⋅)+ and (⋅)− are shortcut notations for max(0, ⋅) and min(0, ⋅), xi the value of pixel i, and where li and hi denote lower

and upper-bounds on pixel values. To implement this rule using the proposed approach, we define the quantities

pj = xi wij − li w+ − hi w− and zj = xi wij and perform the reassignation:

zj ←pj ⋅[zj/pj]cst.

This is done by the code below

In [3]: class ConvPx(torch.nn.Module): def __init__(self, conv):

torch.nn.Module.__init__(self)
self.conv = conv
self.pconv = utils.newlayer(conv, lambda p: p.clamp(min=0)) self.nconv = utils.newlayer(conv, lambda p: p.clamp(max=0))

def forward(self, X): X, L, H = X

z = self.conv.forward(X)
zp = z – self.pconv.forward(L) – self.nconv.forward(H) return zp * (z / zp).data

ij ij

LRP in Next Convolutions (15 P)

In the next convolutions, we would like to apply the LRP-γ rule given by:
R=∑ aj(wjk+γw+) R

jk
j ∑ aj(wjk+γw+) k

k0,j jk
To implement this rule using the proposed approach, we define the quantities pk = aj(wjk + γw+ ) and zk = ajwjk and

perform the reassignation:

zk ←pk ⋅[zk/pk]cst.
Inspired by the code for the first convolution, implement a class for the next convolutions that is equiped to perform the

Task:
LRP-γ propagation when calling the gradient.

In [4]: class Conv(torch.nn.Module):

def __init__(self, conv, gamma):
# ————————————– # TODO: Replace by your code
# ————————————– import solution solution.convinit(self,conv,gamma)
# ————————————–

def forward(self, X):
# ————————————– # TODO: Replace by your code
# ————————————– import solution
return solution.convforward(self,X)
# ————————————–

Now, we can create the LRP-enabled model by replacing the convolution layers with their modified versions.

jk

In [5]:

Note that for the layer 0 and for the subsequent layers, we have used two different classes. Also, the parameter γ is set high in the lower layers and goes increasingly closer to zero as we reach the top convolutions.

We then proceed like Gradient × Input, except for the fact that in the modified first convolution the inputs and gradients not only comprise the pixels x but also the lower and upper bounds l and h. The code below implements this extended Gradient × Input and visualizes the resulting explanation.

lrpmodel = torchvision.models.vgg16(pretrained=True); model.eval() features = lrpmodel._modules[‘features’]

for i in [0]:
for i in [2]:
for i in [5,7]:
for i in [10,12,14]: features[i] = Conv(features[i],10**(-1.0)) for i in [17,19,21]: features[i] = Conv(features[i],10**(-1.5)) for i in [24,26,28]: features[i] = Conv(features[i],10**(-2.0))

features[i] = ConvPx(features[i])
features[i] = Conv(features[i],10**(-0.0))
features[i] = Conv(features[i],10**(-0.5))