# compile our model
print("[INFO] compiling model...")
opt = Adam(lr=INIT_LR, decay=DEC)
model.compile(loss="binary_crossentropy", optimizer=opt, metrics=["accuracy"])
# train the head of the network
print("[INFO] training head...")
H = model.fit_generator(trainAug.flow(trainX, trainY, batch_size=BS),
steps_per_epoch=len(trainX) // BS,
validation_data=(testX, testY),
validation_steps=len(testX) // BS,
epochs=EPOCHS)
# make predictions on the testing set
print("[INFO] evaluating network...")
predIdxs = model.predict(testX, batch_size=BS)
# for each image in the testing set we need to find the index of the label with corresponding largest predicted probability
predIdxs = np.argmax(predIdxs, axis=1)
# show a nicely formatted classification report
print(
classification_report(testY.argmax(axis=1),
predIdxs,
target_names=lb.classes_))
# compute the confusion matrix and and use it to derive the raw accuracy, sensitivity, and specificity
cm = confusion_matrix(testY.argmax(axis=1), predIdxs)
total = sum(sum(cm))
acc = (cm[0, 0] + cm[1, 1]) / total
sensitivity = cm[0, 0] / (cm[0, 0] + cm[0, 1])
# by looking at resnet.layers in the console
partial_model = Model(inputs=resnet.input,
outputs=resnet.layers[175].output)
# maybe useful when building your model
# to look at the layers you're trying to copy
print(partial_model.summary())
# create an instance of our own model
my_partial_resnet = TFResNet()
# make a fake image
X = np.random.random((1, 224, 224, 3))
# get keras output
keras_output = partial_model.predict(X)
### get my model output ###
# init only the variables in our net
init = tf.variables_initializer(my_partial_resnet.get_params())
# note: starting a new session messes up the Keras model
session = keras.backend.get_session()
my_partial_resnet.set_session(session)
session.run(init)
# first, just make sure we can get any output
first_output = my_partial_resnet.predict(X)
print("first_output.shape:", first_output.shape)
def compute_ig_within_GRU(seq2seq,
decoder_states_container,
decoder_inputs_container,
real_h,
target_gate="z",
target_class=[0],
reference=False,
k=32):
"""
Compute ig within GRU for several gates.
Arguments:
decoder_states_container, decoder_inputs_container: For only one time step, the inputs of decoder GRU cell.
target_gate: A list of {"h", "r", "z"}.
target_class: A list of int.
"""
assert target_gate == "z" or target_gate == "r" or target_gate == "h", "No this gate."
print("\nCompute on %s gate." % target_gate)
weight = seq2seq.decoder_model.get_layer("decoder_gru").get_weights()
emb_layer_model = Model(
inputs=seq2seq.decoder_model.get_layer('decoder_emb').get_input_at(-1),
outputs=seq2seq.decoder_model.get_layer('decoder_emb').output)
inputs = np.squeeze(emb_layer_model.predict(decoder_inputs_container,
verbose=0),
axis=1)
states = np.copy(decoder_states_container)
h_tm1, h, z, r, hh, x_h, split_recurrent_h = gruig.get_GRU_components(
inputs, states, weight)
weight_array = np.concatenate(
[weight[0], weight[1],
np.expand_dims(weight[2], axis=0)], axis=0)
units = seq2seq.units
if target_gate == "h":
gate_model = gruig.build_GRU_with_h_gate_model(seq2seq)
gate_model.get_layer("wx_h").set_weights(
[weight[0][:, units * 2:], weight[2][units * 2:]])
gate_model.get_layer("uh_h").set_weights([weight[1][:, units * 2:]])
y = gate_model.predict([h_tm1, inputs, z, r], steps=1)
feed_dict = {
gate_model.input[1]: inputs,
gate_model.input[2]: z,
gate_model.input[3]: r,
}
real = real_h
elif target_gate == "z":
gate_model = gruig.build_GRU_with_z_gate_model(seq2seq, weight_array)
y = gate_model.predict([h_tm1, inputs, r, hh], steps=1)
feed_dict = {
gate_model.input[1]: inputs,
gate_model.input[2]: r,
gate_model.input[3]: hh
}
real = y
elif target_gate == "r":
gate_model = gruig.build_GRU_with_r_gate_model(seq2seq, weight_array)
y = gate_model.predict([h_tm1, inputs, z, x_h, split_recurrent_h],
steps=1)
feed_dict = {
gate_model.input[1]: inputs,
gate_model.input[2]: z,
gate_model.input[3]: x_h,
gate_model.input[4]: split_recurrent_h
}
real = y
assert np.mean(
np.abs(y -
real)) < 1e-6, "Wrong computation for error = %.8f" % np.mean(
np.abs(y - real))
print("delta =", np.mean(np.abs(y - real)))
#assert np.mean(np.abs(y - h)) < 1e-6, "Wrong computation for error = %.8f" % np.mean(np.abs(y - h))
interpolate, num_steps, step_size = linearly_interpolate(
decoder_states_container) # (50, N, 10), int, (N, 10)
result = np.zeros(decoder_states_container.shape) # (N, 256),
total_result = np.zeros(decoder_states_container.shape)
sess = K.get_session()
for class_ in target_class:
print("Class index =", class_)
gradient = gradients(gate_model.output[:, class_], gate_model.input[0])
result = np.zeros(decoder_states_container.shape)
for i in range(num_steps):
feed_dict[gate_model.input[0]] = interpolate[i]
x = sess.run(gradient[0], feed_dict=feed_dict)
result += x
result = np.multiply(result, step_size)
"""if target_gate == "h":
score = np.abs(np.mean(result, axis=0))
print("selected =", list(np.argsort(score)[::-1][:k]))
print("other =", list(np.argsort(score)[::-1][k:]))
print(np.sort(score)[::-1][:4]) """
total_result += result
total_result /= float(len(target_class))
score = np.abs(np.mean(total_result, axis=0))
print("(total) selected =", list(np.argsort(score)[::-1][:k]))
#print("other =", list(np.argsort(score)[::-1][k:]))
print(np.sort(score)[::-1][:4])
return score
