def generate_saliencies(self, state, contrastive = False):
eb.use_eb(True)
state = Variable(torch.Tensor(state)).unsqueeze(0)
saliencies = {}
for idx, choice in enumerate(self.adaptive.choices):
choice_saliencies = {}
prob_outputs = Variable(torch.zeros((len(self.adaptive.choices),)))
prob_outputs[idx] = 1
for reward_idx, reward_type in enumerate(self.adaptive.reward_types):
#TODO better way to do this
explainable_model = HRAModel(self.adaptive.name + "_explain", self.adaptive.network_config, restore = False)
explainable_model.replace(self.adaptive.eval_model)
explainable_model.clear_weights(reward_idx)
layer_top = explainable_model.top_layer(reward_idx)
saliency = eb.excitation_backprop(explainable_model.model, state, prob_outputs, contrastive = contrastive, layer_top = layer_top, target_layer = 0)
choice_saliencies[reward_type] = np.squeeze(saliency.view(*state.shape).data.numpy())
# for overall reward
saliency = eb.excitation_backprop(self.adaptive.eval_model.model, state, prob_outputs, contrastive = contrastive, target_layer = 0)
choice_saliencies["all"] = np.squeeze(saliency.view(*state.shape).data.numpy())
saliencies[choice] = choice_saliencies
eb.use_eb(False)
return saliencies
def gen_eb(path, model_name, show=True):
# get model
model = models.__dict__[model_name](pretrained=True)
#model = models.vgg19(pretrained=True)
_ = model.train(False) # put model in evaluation mode
# get imagenet class labels from local file
class_labels = []
with open('techniques/excitationbp/data/imagenet/labels.txt', 'r') as f:
for line in f:
class_labels.append(line[:-1])
eb.use_eb(True)
inputs = read_tensor(path)
inputs = Variable(inputs.resize_(1, 3, 224, 224), requires_grad=True)
y_hat = model(inputs)
class_id = y_hat.max(1)[1].data.numpy()[0]
# compute excitation backprop for correct label
prob_outputs_cat = Variable(torch.zeros(1, 1000))
prob_outputs_cat.data[:, class_id] += 1
prob_inputs_cat = eb.excitation_backprop(model,
inputs,
prob_outputs_cat,
contrastive=False)
beta = 0.5 # adjust the 'peakiness' of data
cat_img = prob_inputs_cat.clamp(min=0).sum(0).sum(0).data.numpy()
print(cat_img.shape)
if show:
plt.imshow(cat_img**beta, cmap='gray')
return cat_img
def obtain_ceb_prob_inputs(inputs, y, p, hl, model, pyes=True):
eb.use_eb(True)
true_id_0 = y.data[0]
true_id_1 = y.data[1]
parity = ["even", "odd"]
true_p_0 = p.data[0]
true_p_1 = p.data[1]
highlow = ["low", "high"]
true_hl_0 = hl.data[0]
true_hl_1 = hl.data[1]
prob_outputs_true_p_even = Variable(torch.zeros(1, 4))
prob_outputs_true_p_even.data[:, 0] += 1
prob_outputs_true_p_even.data[:, 2] += 1
prob_outputs_true_p_odd = Variable(torch.zeros(1, 4))
prob_outputs_true_p_odd.data[:, 1] += 1
prob_outputs_true_p_odd.data[:, 3] += 1
prob_outputs_true_hl_low = Variable(torch.zeros(1, 4))
prob_outputs_true_hl_low.data[:, 0] += 1
prob_outputs_true_hl_low.data[:, 2] += 1
prob_outputs_true_hl_high = Variable(torch.zeros(1, 4))
prob_outputs_true_hl_high.data[:, 1] += 1
prob_outputs_true_hl_high.data[:, 3] += 1
if pyes:
prob_outputs_true_0 = prob_outputs_true_p_even
prob_outputs_true_1 = prob_outputs_true_p_odd
top_layer_num = -3
else:
prob_outputs_true_0 = prob_outputs_true_hl_low
prob_outputs_true_1 = prob_outputs_true_hl_high
top_layer_num = -1
if useCuda:
prob_outputs_true_0 = prob_outputs_true_0.type(torch.cuda.FloatTensor)
prob_outputs_true_1 = prob_outputs_true_1.type(torch.cuda.FloatTensor)
prob_inputs_true_0 = eb.excitation_backprop(model,
inputs,
prob_outputs_true_0,
contrastive=True,
top_layer=top_layer_num)
prob_inputs_true_1 = eb.excitation_backprop(model,
inputs,
prob_outputs_true_1,
contrastive=True,
top_layer=top_layer_num)
if useCuda:
prob_inputs_true_0 = prob_inputs_true_0.type(torch.cuda.FloatTensor)
prob_inputs_true_1 = prob_inputs_true_1.type(torch.cuda.FloatTensor)
return prob_inputs_true_0, prob_inputs_true_1
def predict(self, state):
self.steps += 1
saliencies = []
# add to experience
if self.previous_state is not None:
experience = Experience(self.previous_state, self.previous_action,
self.current_reward, state)
self.replay_memory.add(experience)
if self.learning and self.should_explore():
action = np.random.choice(len(self.choices))
q_values = [None] * len(
self.choices
) # TODO should it be output shape or from choices?
choice = self.choices[action]
else:
_state = Variable(torch.Tensor(state)).unsqueeze(0)
q_values = self.eval_model.predict(_state)
q_values = q_values.data.numpy()[0]
action = np.argmax(q_values)
choice = self.choices[action]
if self.explanation:
eb.use_eb(True)
prob_outputs = Variable(torch.zeros((len(self.choices), )))
for action in range(len(self.choices)):
prob_outputs[action] = 1
saliency = eb.excitation_backprop(self.eval_model.model,
_state,
prob_outputs,
contrastive=False)
saliency = np.squeeze(
saliency.view(*_state.shape).data.numpy())
saliencies.append(saliency)
if self.learning and self.steps % self.update_frequency == 0:
logger.debug("Replacing target model for %s" % self.name)
self.target_model.replace(self.eval_model)
self.update()
self.current_reward = 0
self.previous_state = state
self.previous_action = action
return choice, q_values, saliencies
def generate_saliency(self, input, target):
eb.use_eb(True)
inputs = Variable(torch.Tensor(input))
prob_outputs_zero = Variable(torch.zeros(1, 4))
zero_id = target
prob_outputs_zero.data[0:1, zero_id] += 1
prob_inputs_zero = eb.excitation_backprop(net,
inputs,
prob_outputs_zero,
contrastive=True)
ebX = prob_inputs_zero.view(inputs.shape).data.abs()
#print(input)
#torch.set_printoptions(threshold=10000)
#print(input.numpy().shape)
#f = open('input.txt', 'w+')
#f.write(str(input.numpy()))
#f.close()
return ebX
def forward(self, x, label):
h1 = self.maxpool1(F.relu(self.cnn1(x)))
h2 = self.maxpool2(F.relu(self.cnn2(h1)))
h3 = self.maxpool3(F.relu(self.cnn3(h2)))
h4 = self.flatten(h3)
h5 = F.relu(self.fc1(h4))
model2 = latterModel(copy.deepcopy(self.fc2), copy.deepcopy(self.fc3))
eb.use_eb(True, verbose=False)
peb_list = []
mask = None
retain_p = None
if self.training:
data = h5.clone()
for i in range(self.batch_size):
prob_outputs = Variable(torch.zeros(1, 10)).to(device)
prob_outputs.data[:, label[i]] += 1
prob_inputs = eb.excitation_backprop(
model2, data[i:i + 1, :], prob_outputs,
contrastive=False, target_layer=0)
peb_list.append(prob_inputs)
pebs = torch.cat(peb_list, dim=0) # calc peb
mask, retain_p = DropoutMask.mask(pebs) # calc mask
peb_entropy = Entropy_Calc.peb_entropy_calc(pebs) # calc peb entropy val
self.ed.peb_entropy = peb_entropy
self.ed.peek_peb = torch.max(pebs) # update peek peb
eb.use_eb(False, verbose=False)
self.ed.train = self.training # ugly code!
self.ed.mask = mask
self.ed.retain_p = retain_p
h_ed = self.ed(h5)
h6 = F.relu(self.fc2(h_ed))
h7 = self.fc3(h6)
return h7
def ceb_pred_accuracy(prob_input, prob_0_1, y, p, hl, model, pyes=True):
eb.use_eb(False)
ceb_input = (prob_input).clamp(min=0)
newX = Variable(ceb_input / ceb_input.max(1)[0] * 1.7)
if useCuda:
newX = newX.type(torch.cuda.FloatTensor)
model = model.cuda()
logits = model(newX)
if pyes:
target_ind = (p == prob_0_1).nonzero() # 0 or 1
target_digit = y[p == prob_0_1] #0~9
target_parity = prob_0_1
target_highlow = hl[p == prob_0_1]
else:
target_ind = (hl == prob_0_1).nonzero() # 0 or 1
target_digit = y[hl == prob_0_1] #0~9
target_parity = p[hl == prob_0_1]
target_highlow = prob_0_1
if pyes:
target_y_hat = F.softmax(
logits[0][:, (0 + target_ind * 10):(10 + target_ind * 10)], dim=-1)
else:
target_y_hat = F.softmax(
logits[2][:, (0 + target_ind * 10):(10 + target_ind * 10)], dim=-1)
#target_y_hat = F.softmax(logits[0][:,(0+target_ind*10):(10+target_ind*10)], dim=-1)
target_digit_prob = target_y_hat[:, target_digit].data
target_p_hat = F.softmax(
logits[1][:, (0 + target_ind * 2):(2 + target_ind * 2)], dim=-1)
target_parity_prob = target_p_hat[:, target_parity].data
target_hl_hat = F.softmax(
logits[3][:, (0 + target_ind * 2):(2 + target_ind * 2)], dim=-1)
target_highlow_prob = target_hl_hat[:, target_highlow].data
pred_digit = target_y_hat.data.max(1)[1]
pred_digit_prob = target_y_hat.data.max(1)[0]
pred_parity = target_p_hat.data.max(1)[1]
pred_parity_prob = target_p_hat.data.max(1)[0]
pred_highlow = target_hl_hat.data.max(1)[1]
pred_highlow_prob = target_hl_hat.data.max(1)[0]
digit_correct = Variable(target_digit == pred_digit).type(
torch.LongTensor).data
parity_correct = Variable(target_parity == pred_parity).type(
torch.LongTensor).data
highlow_correct = Variable(target_highlow == pred_highlow).type(
torch.LongTensor).data
nontarget_ind = 1 - target_ind
if pyes:
nontarget_y_hat = F.softmax(
logits[0][:, (0 + nontarget_ind * 10):(10 + nontarget_ind * 10)],
dim=-1)
else:
nontarget_y_hat = F.softmax(
logits[2][:, (0 + nontarget_ind * 10):(10 + nontarget_ind * 10)],
dim=-1)
#nontarget_y_hat = F.softmax(logits[0][:,(0+nontarget_ind*10):(10+nontarget_ind*10)], dim=-1)
nontarget_max_digit = nontarget_y_hat.data.max(1)[1]
nontarget_max_digit_prob = nontarget_y_hat.data.max(1)[0]
nontarget_p_hat = F.softmax(
logits[1][:, (0 + nontarget_ind * 2):(2 + nontarget_ind * 2)], dim=-1)
nontarget_max_parity = nontarget_p_hat.data.max(1)[1]
nontarget_max_parity_prob = nontarget_p_hat.data.max(1)[0]
nontarget_hl_hat = F.softmax(
logits[3][:, (0 + nontarget_ind * 2):(2 + nontarget_ind * 2)], dim=-1)
nontarget_max_highlow = nontarget_hl_hat.data.max(1)[1]
nontarget_max_highlow_prob = nontarget_hl_hat.data.max(1)[0]
return_list = [digit_correct, parity_correct, highlow_correct, target_digit_prob, target_parity_prob, target_highlow_prob, \
pred_digit_prob, pred_parity_prob, pred_highlow_prob, \
nontarget_max_digit_prob, nontarget_max_parity_prob, nontarget_max_highlow_prob, \
target_digit, target_parity, target_highlow, \
pred_digit, pred_parity, pred_highlow, \
nontarget_max_digit, nontarget_max_parity, nontarget_max_highlow]
return return_list