def preview_activations(model, sample, title):
"""
This function allows to preview the activations through the model.
"""
activations = backend.function([model.layers[0].input], [
model.layers[0].output, model.layers[1].output, model.layers[2].output,
model.layers[3].output, model.layers[4].output, model.layers[5].output,
model.layers[6].output, model.layers[7].output
])
output = activations(sample)
fig = plt.figure()
fig.suptitle(title)
plt.subplots_adjust(hspace=0.5)
gs = gridspec.GridSpec(8, 1)
def add_volume_activation(n, title):
act = output[n]
w = act.shape[-1]
g = gridspec.GridSpecFromSubplotSpec(1, w, subplot_spec=gs[n])
for i in range(w):
ax = fig.add_subplot(g[i])
ax.imshow(act[0, :, :, i], cmap='gray')
ax.set_xticks([])
ax.set_yticks([])
if float(w) / float(i + 1) == 2:
ax.set_title(title)
add_volume_activation(0, "First Convolutional layer output")
add_volume_activation(1, "First MaxPooling layer output")
add_volume_activation(2, "Second Convolutional layer output")
add_volume_activation(3, "Second MaxPooling layer output")
def add_flat_activation(n, title):
act = output[n]
w = act.shape[-1]
g = gridspec.GridSpecFromSubplotSpec(1, 1, subplot_spec=gs[n])
ax = fig.add_subplot(g[0])
ax.imshow(act, cmap='gray')
ax.set_xticks([])
ax.set_yticks([])
ax.set_title(title)
add_flat_activation(4, "Flatten layer output")
add_flat_activation(5, "First Dense layer output")
add_flat_activation(6, "Second Dense layer output")
add_flat_activation(7, "Output layer output")
plt.show()
def run_graph(self, images, outputs, image_metas=None):
"""Runs a sub-set of the computation graph that computes the given
outputs.
image_metas: If provided, the images are assumed to be already
molded (i.e. resized, padded, and normalized)
outputs: List of tuples (name, tensor) to compute. The tensors are
symbolic TensorFlow tensors and the names are for easy tracking.
Returns an ordered dict of results. Keys are the names received in the
input and values are Numpy arrays.
"""
model = self.keras_model
# Organize desired outputs into an ordered dict
outputs = OrderedDict(outputs)
for o in outputs.values():
assert o is not None
# Build a Keras function to run parts of the computation graph
inputs = model.inputs
if model.uses_learning_phase and not isinstance(K.learning_phase(), int):
inputs += [K.learning_phase()]
kf = K.function(model.inputs, list(outputs.values()))
# Prepare inputs
if image_metas is None:
molded_images, image_metas, _ = self.mold_inputs(images)
else:
molded_images = images
image_shape = molded_images[0].shape
# Anchors
anchors = self.get_anchors(image_shape)
# Duplicate across the batch dimension because Keras requires it
# TODO: can this be optimized to avoid duplicating the anchors?
anchors = np.broadcast_to(anchors, (self.config.BATCH_SIZE,) + anchors.shape)
model_in = [molded_images, image_metas, anchors]
# Run inference
if model.uses_learning_phase and not isinstance(K.learning_phase(), int):
model_in.append(0.)
outputs_np = kf(model_in)
# Pack the generated Numpy arrays into a a dict and log the results.
outputs_np = OrderedDict([(k, v)
for k, v in zip(outputs.keys(), outputs_np)])
for k, v in outputs_np.items():
log(k, v)
return outputs_np
def __build_train_fn(self):
"""Create a train function
It replaces `model.fit(X, y)` because we use the output of model and use it for training.
For example, we need action placeholder
called `action_one_hot` that stores, which action we took at state `s`.
Hence, we can update the same action.
This function will create
`self.train_fn([state, action_one_hot, discount_reward])`
which would train the model.
"""
# """ Placeholders """
# input_placeholder = K.placeholder(shape=(None, *self.input_dim), name='model_inputs')
# actions_placeholder = K.placeholder(shape=(None,), dtype='uint8', name="selected_actions")
# rewards_placeholder = K.placeholder(shape=(None,), name="discount_reward")
#
# """ Internal operations """
# output_tensor = self.model(input_placeholder)
# action_onehot_placeholder = K.one_hot(indices=actions_placeholder, num_classes=self.output_dim)
#
# action_prob = K.sum(output_tensor * action_onehot_placeholder, axis=1)
# log_action_prob = K.log(action_prob + K.epsilon())
#
# loss = - log_action_prob * rewards_placeholder
# total_loss = K.mean(loss)
#
# nn_train = K.function(inputs=[input_placeholder, actions_placeholder, rewards_placeholder],
# outputs=[total_loss],
# updates=Adam(lr=self.learning_rate).get_updates(total_loss, self.model.trainable_weights))
# # updates=Adam(lr=5e-6, beta_1=0.5, beta_2=0.999).get_updates(total_loss, self.model.trainable_weights))
#
# self.train_fn = nn_train
# ==================================================================================================================================================================================================================================
""" Placeholders """
observations_placeholder = K.placeholder(shape=(None, *self.input_dim), name='model_inputs')
actions_placeholder = K.placeholder(shape=(None,), dtype='uint8', name="selected_actions")
rewards_placeholder = K.placeholder(shape=(None,), name="discounted_rewards")
""" Internal operations """
Ylogits = self.model(observations_placeholder)
cross_entropies = K.categorical_crossentropy(target=K.one_hot(indices=actions_placeholder, num_classes=self.output_dim),
output=Ylogits,
from_logits=True) # from_logits=False
loss = K.mean(rewards_placeholder * cross_entropies)
nn_train = K.function(inputs=[observations_placeholder, actions_placeholder, rewards_placeholder],
outputs=[loss],
updates=Adam(lr=self.learning_rate).get_updates(loss, self.model.trainable_weights)) # RMSprop().get_updates(loss=loss, params=self.model.trainable_weights)
self.train_fn = nn_train
def show_visualization(model, hyperparameters):
# model = load_model()
print(model.summary)
Sample = '/Lab1/Lab2/Bone/train/AFF/14.jpg'
Img = imread(Sample)
print(Img.shape)
# Img = Img[:,:,0]
Img = Img / 255
img_height, img_width = hyperparameters['input_shape'][0], hyperparameters[
'input_shape'][1]
Img = resize(Img, (img_height, img_width),
anti_aliasing=True).astype('float32')
# Img = np.expand_dims(Img, axis = 2)
print(Img.shape)
Img = np.expand_dims(Img, axis=0)
print(Img.shape)
preds = model.predict(Img)
class_idx = np.argmax(preds[0])
print(class_idx)
class_output = model.output[:, class_idx]
last_conv_layer = model.get_layer("conv2d_12")
print(last_conv_layer.output)
grads = K.gradients(class_output, last_conv_layer.output)[0]
pooled_grads = K.mean(grads, axis=(0, 1, 2))
iterate = K.function([model.input],
[pooled_grads, last_conv_layer.output[0]])
pooled_grads_value, conv_layer_output_value = iterate([Img])
for i in range(hyperparameters['base'] * 8):
conv_layer_output_value[:, :, i] *= pooled_grads_value[i]
heatmap = np.mean(conv_layer_output_value, axis=-1)
heatmap = np.maximum(heatmap, 0)
heatmap /= np.max(heatmap)
# For visualization
img = cv2.imread(Sample)
img = cv2.resize(img, (512, 512), interpolation=cv2.INTER_AREA)
heatmap = cv2.resize(heatmap, (img.shape[1], img.shape[0]))
heatmap = np.uint8(255 * heatmap)
heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
superimposed_img = cv2.addWeighted(img, 0.6, heatmap, 0.4, 0)
fig = plt.figure()
plt.imshow(img)
result_path = os.path.join(os.path.join(os.getcwd(), 'results'),
"Task 10_img.png")
fig.savefig(result_path, dpi=fig.dpi)
fig = plt.figure()
plt.imshow(superimposed_img)
result_path = os.path.join(os.path.join(os.getcwd(), 'results'),
"Task 10_superimposed_img.png")
fig.savefig(result_path, dpi=fig.dpi)
def test_quantized_sigmoid(bits, sigmoid_type, use_real_sigmoid, test_values,
expected_values):
"""Test quantized_sigmoid function with three different sigmoid variants."""
set_internal_sigmoid(sigmoid_type)
x = K.placeholder(ndim=2)
f = K.function([x], [
quantized_sigmoid(
bits, symmetric=True, use_real_sigmoid=use_real_sigmoid)(x)
])
set_internal_sigmoid(_default_sigmoid_type)
result = f([test_values])[0]
assert_allclose(result, expected_values, rtol=1e-05)
def build_combined(self):
z = tfk.Input(shape=(self.dim, ))
img = self.generator(z)
valid = self.discriminator(img)
model = tfk.models.Model(z, valid)
#model.summary()
loss = -1. * K.mean(valid)
training_updates = tfk.optimizers.Adam(
lr=1e-4, beta_1=0.5,
beta_2=0.9).get_updates(loss, self.generator.trainable_weights)
g_train = K.function([z], [loss], training_updates)
return model, g_train
def Grad_CAM(model, x, layer_name):
#Change the learning phase into test mode
backend.set_learning_phase(0)
#Print the binary classification score
print("Prediction score: " + str(model.predict(x)[0, 0]))
#Get the original image size
row = model.get_layer[0].output_shape[0][1]
column = model.get_layer[0].output_shape[0][2]
print("Input_size: " + str((row, column)))
#Function to get final conv_output and gradients
true_output = model.layers[-1].output #Output of the truely final layer
mid_output = model.get_layer(
layer_name).output #Output of the final convolutional layer
grads = backend.gradients(
true_output,
mid_output)[0] #Calculate the "gradients(loss, variables)"
mean_grads = backend.mean(grads, axis=(1, 2)) #Average the gradients
gradient_function = backend.function([model.input],
[mid_output, mean_grads])
#Get the output of final conv_layer and the weight for each kernel (mean gradients)
conv_output, kernel_weights = gradient_function([x])
conv_output, kernel_weights = conv_output[0], kernel_weights[0]
#Get the Class Activation Mapping (CAM)
cam = conv_output @ kernel_weights
#Caution! cv2-resize-shape is reverse of numpy-shape
cam = cv2.resize(cam, (column, row), cv2.INTER_LINEAR) #Scale up
cam = np.maximum(cam,
0) #We have no interest in negative value (like ReLu)
cam = 255 * cam / cam.max() #Normalize
#Get together with original image
original = x[0, :, :, 0][:, :, np.newaxis] #Cut out the derivatives
original = np.uint8(255 * (original - original.min()) /
(original.max() - original.min()))
heatmap = cv2.applyColorMap(np.uint8(cam),
cv2.COLORMAP_OCEAN) #Add color to heat map
heatmap = cv2.cvtColor(heatmap,
cv2.COLOR_BGR2RGB) #Convert it into color map
plusCAM = (np.float32(heatmap) * 0.4 + original * 0.6
) #Mix original image with heatmap
plusCAM = np.uint8(255 * plusCAM / plusCAM.max())
#Return the CAM data
return original, heatmap, plusCAM
def activation_weights(net, im, list_layers):
H = [None] * len(list_layers)
for i in range(0, len(list_layers)):
q = im
q = np.expand_dims(q, axis=0)
activations = K.function([net.layers[0].input],
net.get_layer(name=list_layers[i]).output)
act1 = activations([q, 0])
imgSize = im.shape[0:2]
_, _, _, maxValueIndex = np.where(act1 >= act1.max())
act1chMax = act1[:, :, :, maxValueIndex[0]]
act1chMax = (act1chMax - act1chMax.min()) / act1chMax.max()
H[i] = act1chMax
return H
def build_model(self):
"""Build a critic (value) network that maps (state, action) pairs -> Q-values."""
# Define input layers
states = layers.Input(shape=(self.state_size, ), name='states')
actions = layers.Input(shape=(self.action_size, ), name='actions')
# Add hidden layer(s) for state pathway
net_states = layers.Dense(units=64, activation='relu')(states)
net_states = layers.BatchNormalization()(net_states)
net_states = layers.Dropout(0.4)(net_states)
net_states = layers.Dense(units=128, activation='relu')(net_states)
net_states = layers.BatchNormalization()(net_states)
net_states = layers.Dropout(0.4)(net_states)
net_states = layers.Dense(units=64, activation='relu')(net_states)
net_states = layers.BatchNormalization()(net_states)
net_states = layers.Dropout(0.4)(net_states)
# Add hidden layer(s) for action pathway
net_actions = layers.Dense(units=64, activation='relu')(actions)
net_actions = layers.BatchNormalization()(net_actions)
net_actions = layers.Dropout(0.4)(net_actions)
net_actions = layers.Dense(units=128, activation='relu')(net_actions)
net_actions = layers.BatchNormalization()(net_actions)
net_actions = layers.Dropout(0.4)(net_actions)
net_actions = layers.Dense(units=64, activation='relu')(net_actions)
net_actions = layers.BatchNormalization()(net_actions)
net_actions = layers.Dropout(0.4)(net_actions)
# Combine state and action pathways
net = layers.Add()([net_states, net_actions])
net = layers.Activation('relu')(net)
# Add final output layer to prduce action values (Q values)
Q_values = layers.Dense(units=1, name='q_values')(net)
# Create Keras model
self.model = models.Model(inputs=[states, actions], outputs=Q_values)
# Define optimizer and compile model for training with built-in loss function
optimizer = optimizers.Adam()
self.model.compile(optimizer=optimizer, loss='mse')
# Compute action gradients (derivative of Q values w.r.t. to actions)
action_gradients = K.gradients(Q_values, actions)
# Define an additional function to fetch action gradients (to be used by actor model)
self.get_action_gradients = K.function(
inputs=[*self.model.input, K.learning_phase()],
outputs=action_gradients)
def predict(self, X):
"""Predict output.
Parameters
----------
X : array, shape (n_samples, n_features)
Features.
Returns
-------
y_pred: array, shape (n_samples,)
Model prediction.
"""
ranker_output = K.function([self.model.layers[0].input],
[self.model.layers[-3].get_output_at(0)])
return ranker_output([X])[0].ravel()
def __init__(self, layer: Dense):
super().__init__(layer)
weights = layer.get_weights()
W = weights[0]
b = weights[1]
# Set up_func for DDense
i = Input(shape=layer.input_shape[1:])
o = Dense(units=layer.output_shape[1])(i)
o.weights = [W, b]
self.up_func = K.function([i], [o])
# Transpose W and set down_func for DDense
W = W.transpose()
self.input_shape = layer.input_shape
self.output_shape = layer.output_shape
b = np.zeros(self.input_shape[1])
flipped_weights = [W, b]
i = Input(shape=self.output_shape[1:])
o = Dense(units=self.input_shape[1])(i)
o.weights = flipped_weights
self.down_func = K.function([i], [o])
def generate_pattern(model,layer_name, filter_index, size=28):
layer_output = model.get_layer(layer_name).output
loss = K.mean(layer_output[:, :, :, filter_index])
grads = K.gradients(loss, model.input)[0]
grads /= (K.sqrt(K.mean(K.square(grads))) + 1e-5)
iterate = K.function([model.input], [loss, grads])
input_img_data = np.random.random((1, size, size, 1)) * 20 + 128.
for i in range(500):
loss_value, grads_value = iterate([input_img_data])
input_img_data += grads_value * 1
img = input_img_data[0]
return deprocess_image(img)
def __init__(self, inp_dim, out_dim, lr, tau):
# Dimensions and Hyperparams
self.env_dim = inp_dim
self.act_dim = out_dim
self.tau, self.lr = tau, lr
# Build models and target models
self.model = self.network()
self.target_model = self.network()
self.model.compile(Adam(self.lr), 'mse')
self.target_model.compile(Adam(self.lr), 'mse')
# Function to compute Q-value gradients (Actor Optimization)
self.action_grads = K.function(
[self.model.input[0], self.model.input[1]],
K.gradients(self.model.output, [self.model.input[1]]))
def test_quantized_relu_po2(bits,
max_value,
use_stochastic_rounding,
quadratic_approximation,
test_values,
expected_values):
"""Test quantized_po2 function."""
x = K.placeholder(ndim=2)
f = K.function([x],
[quantized_relu_po2(bits, max_value, 0,
use_stochastic_rounding,
quadratic_approximation)(x)])
result = f([test_values])[0]
assert_allclose(result, expected_values, rtol=1e-05, atol=1e-05)
def predict_on_image(self, image: np.ndarray) -> Tuple[str, float]:
softmax_output_fn = K.function(
[self.network.get_layer('image').input,
K.learning_phase()],
[self.network.get_layer('softmax_output').output])
if image.dtype == np.uint8:
image = (image / 255).astype(np.float32)
# Get the prediction and confidence using softmax_output_fn, passing the right input into it.
##### Your code below (Lab 3)
##### Your code above (Lab 3)
return pred, conf
def train(self):
self.model.compile(optimizer=optimizers.Adam(learning_rate=0.001),
loss=self.loss,
metrics=['mse', 'mae'])
training_history = self.model.fit(self.input_train,
self.input_train,
batch_size=self.batch_size,
epochs=self.epochs,
callbacks=self.callbacks,
validation_data=(self.input_valid,
self.input_valid),
shuffle=True,
verbose=2)
if training_history is not None:
common_util._plot_training_history(training_history,
self.config_model)
common_util._save_model_history(training_history,
self.config_model)
config = dict(self.config_model['kwargs'])
# create config file in log again
config_filename = 'config.yaml'
config['train']['log_dir'] = self.log_dir
with open(os.path.join(self.log_dir, config_filename), 'w') as f:
yaml.dump(config, f, default_flow_style=False)
outputs = K.function([self.model.input],
[self.model.layers[0].output])([self.input_train])
# outputs = [K.function([self.model.input], [layer.output])([self.input_train]) for layer in self.model.layers]
outputs_ae = np.array(outputs[0])
outputs = K.function([self.model.input],
[self.model.layers[0].output])([self.input_valid])
# outputs = [K.function([self.model.input], [layer.output])([self.input_valid]) for layer in self.model.layers]
outputs_ae_valid = np.array(outputs[0])
return outputs_ae, outputs_ae_valid
def test_build_symmetrization_ensemble(model_builder, batch_size):
with DEFAULT_TF_GRAPH.as_default():
keras_model = model_builder()
keras_model.summary()
shape = K.int_shape(keras_model.input)[1:]
symmetrization_input = Input(shape=shape,
dtype=keras_model.input.dtype)
ensemble_input = Input(shape=shape, dtype=keras_model.input.dtype)
symmetrization_model = Model(
inputs=symmetrization_input,
outputs=build_symmetrization_ensemble([
symmetrization_input,
Lambda(lambda x: x * -1)(symmetrization_input)
], keras_model))
ensemble_model = Model(
inputs=ensemble_input,
outputs=build_ensemble([
keras_model(ensemble_input),
keras_model(Lambda(lambda x: x * -1)(ensemble_input))
]))
symmetrization_model_func = K.function(
inputs=[symmetrization_input],
outputs=[symmetrization_model.output])
ensemble_model_func = K.function(inputs=[ensemble_input],
outputs=[ensemble_model.output])
size = (batch_size, ) + K.int_shape(keras_model.input)[1:]
batch = np.random.rand(*size)
symmetrization_model_vals = symmetrization_model_func([batch])[0]
ensemble_model_vals = ensemble_model_func([batch])[0]
assert np.allclose(symmetrization_model_vals,
ensemble_model_vals,
rtol=1e-3)
def __init__(self, input_tensor, losses, input_range=(0, 255), wrt_tensor=None, norm_grads=True):
"""Creates an optimizer that minimizes weighted loss function.
Args:
input_tensor: An input tensor of shape: `(samples, channels, image_dims...)` if `image_data_format=
channels_first` or `(samples, image_dims..., channels)` if `image_data_format=channels_last`.
losses: List of ([Loss](vis.losses.md#Loss), weight) tuples.
input_range: Specifies the input range as a `(min, max)` tuple. This is used to rescale the
final optimized input to the given range. (Default value=(0, 255))
wrt_tensor: Short for, with respect to. This instructs the optimizer that the aggregate loss from `losses`
should be minimized with respect to `wrt_tensor`.
`wrt_tensor` can be any tensor that is part of the model graph. Default value is set to None
which means that loss will simply be minimized with respect to `input_tensor`.
norm_grads: True to normalize gradients. Normalization avoids very small or large gradients and ensures
a smooth gradient gradient descent process. If you want the actual gradient
(for example, visualizing attention), set this to false.
"""
self.input_tensor = input_tensor
self.input_range = input_range
self.loss_names = []
self.loss_functions = []
self.wrt_tensor = self.input_tensor if wrt_tensor is None else wrt_tensor
if self.input_tensor is self.wrt_tensor:
self.wrt_tensor_is_input_tensor = True
# self.wrt_tensor = K.identity(self.wrt_tensor)
self.wrt_tensor = tf.identity(self.wrt_tensor)
else:
self.wrt_tensor_is_input_tensor = False
overall_loss = None
for loss, weight in losses:
# Perf optimization. Don't build loss function with 0 weight.
if weight != 0:
loss_fn = weight * loss.build_loss()
overall_loss = loss_fn if overall_loss is None else overall_loss + loss_fn
self.loss_names.append(loss.name)
self.loss_functions.append(loss_fn)
# Compute gradient of overall with respect to `wrt` tensor.
if self.wrt_tensor_is_input_tensor:
grads = K.gradients(overall_loss, self.input_tensor)[0]
else:
grads = K.gradients(overall_loss, self.wrt_tensor)[0]
if norm_grads:
grads = K.l2_normalize(grads)
# The main function to compute various quantities in optimization loop.
self.compute_fn = K.function([self.input_tensor, K.learning_phase()],
self.loss_functions + [overall_loss, grads, self.wrt_tensor])
def class_activation_map(self, basic_img, img):
"""
Based on: https://jacobgil.github.io/deeplearning/class-activation-maps
Creates a class activation heatmap given based on the loaded model, formats the heatmap
to back to the original dimensions, and creates a superimposed image of the heatmap on
the original image
:unformatted_image: a numpy array of the image, unformatted (for superimposing)
:formatted_image: A formatted numpy array of the image, ready to be passed to the model
:return: A superimposed image depicting class activation based on the model
"""
preds = self.model.predict(img)
output = self.model.output[:, 0]
# Get last convolutional layer from the model
last_conv_layer = self.model.get_layer('conv2d_5')#'final_model_conv')
# Create gradient of the conv layer vs. the final output
grads = backend.gradients(output, last_conv_layer.output)[0]
mean_grads = backend.mean(grads, axis=(0, 1, 2))
# Function to grab the mean gradient and the raw conv layer output given model input
get_cam_vals = backend.function([self.model.input], [mean_grads, last_conv_layer.output[0]])
grads_val, final_conv_val = get_cam_vals([img])
for i in range(last_conv_layer.output.shape[-1]):
final_conv_val[:, :, i] *= grads_val[i]
# Normalize output
cam = np.mean(final_conv_val, axis=-1)
cam /= np.max(cam)
mapping = cm.get_cmap('rainbow_r')
heatmap = mapping(np.uint8(255 * cam))
#heatmap[np.where(cam > 0.5)] = 0 # thresholding
# Convert heatmap back to original image dimensions
heatmap = resize(heatmap, (basic_img.shape[0], basic_img.shape[1]))
opacity = 0.4
superimposed_img = np.array([
heatmap[:,:,0] * opacity + basic_img,
heatmap[:,:,1] * opacity + basic_img,
heatmap[:,:,2] * opacity + basic_img])
superimposed_img = superimposed_img.transpose(1,2,0)
superimposed_img /= np.max(superimposed_img)
return superimposed_img
def build_model(self):
"""Build a critic (value) network that maps (state, action) pairs -> Q-values."""
# Define input layers
states = layers.Input(shape=(self.state_size, ), name='states')
actions = layers.Input(shape=(self.action_size, ), name='actions')
# Add hidden layer(s) for state pathway
net_states = layers.Dense(units=self.units[0],
activation='relu')(states)
net_states = layers.Dense(units=self.units[1],
activation='relu')(net_states)
# Add hidden layer(s) for action pathway
net_actions = layers.Dense(units=self.units[0],
activation='relu')(actions)
net_actions = layers.Dense(units=self.units[1],
activation='relu')(net_actions)
# Try different layer sizes, activations, add batch normalization, regularizers, etc.
# Combine state and action pathways
net = layers.Add()([net_states, net_actions])
net = layers.Activation('relu')(net)
# Add more layers to the combined network if needed
net = layers.Dense(units=self.units[0], activation='relu')(net)
net = layers.Dense(units=self.units[1], activation='relu')(net)
# Add final output layer to prduce action values (Q values)
Q_values = layers.Dense(units=1,
name='q_values',
kernel_initializer=initializers.RandomUniform(
minval=-1, maxval=1))(net)
# Create Keras model
self.model = models.Model(inputs=[states, actions], outputs=Q_values)
# Define optimizer and compile model for training with built-in loss function
optimizer = optimizers.Adam(learning_rate=1e-4)
self.model.compile(optimizer=optimizer, loss='mse')
# Compute action gradients (derivative of Q values w.r.t. to actions)
action_gradients = backend.gradients(Q_values, actions)
# Define an additional function to fetch action gradients (to be used by actor model)
self.get_action_gradients = backend.function(
inputs=[*self.model.input,
backend.learning_phase()],
outputs=action_gradients)
def _log_gradients(self):
if not self.training_data:
raise ValueError(
"Need to pass in training data if logging gradients")
X_train = self.training_data[0]
y_train = self.training_data[1]
metrics = {}
weights = self.model.trainable_weights # weight tensors
# filter down weights tensors to only ones which are trainable
weights = [
weight for weight in weights
if self.model.get_layer(weight.name.split("/")[0]).trainable
]
gradients = self.model.optimizer.get_gradients(
self.model.total_loss, weights) # gradient tensors
if hasattr(self.model, "targets"):
# TF < 1.14
target = self.model.targets[0]
sample_weight = self.model.sample_weights[0]
elif (hasattr(self.model, "_training_endpoints")
and len(self.model._training_endpoints) > 0):
# TF > 1.14 TODO: not sure if we're handling sample_weight properly here...
target = self.model._training_endpoints[0].training_target.target
sample_weight = self.model._training_endpoints[
0].sample_weight or K.variable(1)
else:
wandb.termwarn(
"Couldn't extract gradients from your model, this could be an unsupported version of keras. File an issue here: https://github.com/wandb/client",
repeat=False,
)
return metrics
input_tensors = [
self.model.inputs[0], # input data
# how much to weight each sample by
sample_weight,
target, # labels
K.learning_phase(), # train or test mode
]
get_gradients = K.function(inputs=input_tensors, outputs=gradients)
grads = get_gradients([X_train, np.ones(len(y_train)), y_train])
for (weight, grad) in zip(weights, grads):
metrics["gradients/" + weight.name.split(":")[0] +
".gradient"] = wandb.Histogram(grad)
return metrics
def get_gradients_at_node(model, node, x, learning_phase=0):
'''
Gets a keras model and returns the gradient of a node with respect to the input layer at point x
Input:
model: the model to be evaluated, an instance of keras.model.Model
a scalar tensor.
an input to model (the point at which the gradient is evaluated), without batch dimension.
learning_phase: 0 or 1 depending on whether inference should be in training mode or not.
Output:
numpy array of dimension 1 * x.shape, that contains the gradient dy/dx (x), where y is node, x is model inputs and x is the point x at which the gradient is evaluated
'''
inputs = model.input
grad = tf.gradients(node, inputs)[0]
func = K.function([inputs, K.learning_phase()], grad)
return np.array(func([np.expand_dims(x, 0), learning_phase]))
def get_activation_matrix(model, X, layers=None):
"""
Returns the activation matrix for a Model, a Layer or a list of Layers
and a set of Model input values.
"""
if layers is None:
layers = model.layers
targets = [layer.output for layer in layers]
outputs = K.function([model.layers[0].input], targets)
activations = outputs([np.array(X)])
return np.concatenate(activations, axis=-1)
def attention_lstm_expliable(hidden_size, max_len, max_features, v_size):
inp = Input(shape=(None, ), dtype="int32", name='inputs')
x = Embedding(max_features, v_size)(inp)
encoder_lstm = LSTM(hidden_size,
return_sequences=True,
name='encoder_lstm')
x = encoder_lstm(x)
attwithcontext = AttentionWithContext()
x = attwithcontext(x)
# Add a classifier
outputs = Dense(1, activation="sigmoid")(x)
model = Model(inp, outputs)
model.summary()
fn = K.function([inp], [attwithcontext.att_weights])
return model, fn
def _create_mtcnn(self, sess, model_path):
if not model_path:
model_path, _ = os.path.split(os.path.realpath(__file__))
with tf.variable_scope('pnet'):
data = tf.placeholder(tf.float32, (None, None, None, 3), 'input')
pnet = mtcnn_detect_face.PNet({'data': data})
pnet.load(os.path.join(model_path, 'det1.npy'), sess)
with tf.variable_scope('rnet'):
data = tf.placeholder(tf.float32, (None, 24, 24, 3), 'input')
rnet = mtcnn_detect_face.RNet({'data': data})
rnet.load(os.path.join(model_path, 'det2.npy'), sess)
with tf.variable_scope('onet'):
data = tf.placeholder(tf.float32, (None, 48, 48, 3), 'input')
onet = mtcnn_detect_face.ONet({'data': data})
onet.load(os.path.join(model_path, 'det3.npy'), sess)
self.pnet = K.function([pnet.layers['data']],
[pnet.layers['conv4-2'], pnet.layers['prob1']])
self.rnet = K.function([rnet.layers['data']],
[rnet.layers['conv5-2'], rnet.layers['prob1']])
self.onet = K.function([onet.layers['data']], [
onet.layers['conv6-2'], onet.layers['conv6-3'],
onet.layers['prob1']
])
def max_entropy(learner, X, n_instances=1, T=100):
random_subset = np.random.choice(X.shape[0], 2000, replace=False)
MC_output = K.function(
[learner.estimator.model.layers[0].input,
K.learning_phase()], [learner.estimator.model.layers[-1].output])
learning_phase = True
MC_samples = [
MC_output([X[random_subset], learning_phase])[0] for _ in range(T)
]
MC_samples = np.array(MC_samples)
expected_p = np.mean(MC_samples, axis=0)
acquisition = -np.sum(expected_p * np.log(expected_p + 1e-10), axis=1)
idx = (-acquisition).argsort()[:n_instances]
query_idx = random_subset[idx]
return query_idx, X[query_idx]
def build_model(hidden_layers, activation='tanh',alpha=1e-3,penalty_order=3,penalty_loss='l1'):
inputs = keras.Input(shape=(1,))
for i,hidden in enumerate(hidden_layers):
if i == 0:
h = keras.layers.Dense(hidden,activation='linear', kernel_initializer=keras.initializers.glorot_normal)(inputs)
else:
h = keras.layers.Dense(hidden,activation='linear')(h)
if activation == 'tanh':
h = K.tanh(h)
elif activation == 'sine':
h = K.sin(h)
elif activation == 'elu':
h = K.elu(h)
elif activation == 'sigmoid':
h = K.sigmoid(h)
elif activation == 'relu':
h = K.relu(h)
#h = keras.layers
#h = keras.layers.Dropout(rate=0.8)(h)
#h = keras.layers.BatchNormalization()(h)
outputs = keras.layers.Dense(1,activation='linear')(h)
model = keras.Model(inputs, outputs)
grad1 = K.gradients(model.output, model.input)[0]
iterate1 = K.function([model.input], [grad1])
grad2 = K.gradients(grad1, model.input)[0]
iterate2 = K.function([model.input], [grad2])
if penalty_order == 2:
tt = grad2
elif penalty_order == 3:
grad3 = K.gradients(grad2, model.input)[0]
tt = grad3
if penalty_loss == 'l1':
model.compile(optimizer='Adam', loss=penalty_l1(tt, alpha=alpha))
elif penalty_loss == 'l2':
model.compile(optimizer='Adam', loss=penalty_l2(tt, alpha=alpha))
return model,iterate1,iterate2
def test():
model = vggvox_model()
num_layers = len(model.layers)
print(model.summary())
x = np.random.randn(1, 512, 30, 1)
outputs = []
for i in range(num_layers):
get_ith_layer_output = K.function([model.layers[0].input, K.learning_phase()],
[model.layers[i].output])
layer_output = get_ith_layer_output([x, 0])[0] # output in test mode = 0
outputs.append(layer_output)
for i in range(11):
print("Shape of layer {} output:{}".format(i, outputs[i].shape))
def __init__(self,
model,
output,
stat_functions,
stat_names,
input_data_feed,
axis=0):
self.model = model
self.output = output
self.stat_list = stat_functions
self.stat_names = stat_names
self.func = K.function([self.model.input], [output])
self.input = input_data_feed
self.axis = axis
def extract_features(feature_extractor, x):
nf = []
outputs = []
functors = []
for layer in feature_extractor.layers:
if layer.name in ["block1_pool", "block2_pool", "block3_pool"]:
nf.append(np.prod(layer.output_shape[1:]))
functors.append(layer.output)
appl = K.function([feature_extractor.input, K.learning_phase()], functors)
outputs = appl([x, 1.])
outputs = [out[0] for out in outputs]
return outputs, nf
